@raidiant/notifai 11.7.1-beta.2 → 12.0.0-beta.5

package/dist/commands-init.js

@@ -1,901 +0,0 @@
-import { CAPABILITIES_V1, validateDraft, } from '@raidiant/notifai-protocol';
-import { randomBytes } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
-import { ApiCallError, NetworkError } from './client.js';
-import { sharedProjectConfigPath } from './config.js';
-import { projectSlugFrom as inferredProjectSlugFrom } from './invocation-context.js';
-import { conventionalSkillPath } from './native-skills.js';
-import { canonicalPath } from './local-path.js';
-import { firstRequiredBlocker, isOptionalAutomation, isOptionalSetup, questionRoutingReady, readinessJson, } from './readiness.js';
-import { buildDraft, formatReceipt } from './send.js';
-import { loginCommand } from './commands-auth.js';
-import { EXIT, SETUP_COMMAND, authedClient, loadLoggedConfig, reportError, updateCliCommand, } from './commands-core.js';
-import { readyCompanionDevices } from './commands-devices.js';
-import { companionPlatformLabel, setupCompanionUrl, } from './setup-destinations.js';
-import { assessReadiness, remedyLine } from './commands-doctor.js';
-import { hooksInstallCommand, pickHarnessesToInstall } from './commands-hook-install.js';
-import { observedCompanionReceipt, observedSetupProof, readSetupProof, setupProofApplies, setupProofIsStale, writeSetupProof, } from './commands-setup-proof.js';
-import { installedSkillMatchesPackage, listScopedNotifaiSkills, SKILLS_SOURCE } from './commands-skill.js';
-import { enableProject, projectBinding } from './project-enablement.js';
-import { inspectCliInstallations } from './cli-bin.js';
-import { installHookAdapter } from './hook-adapter.js';
-// ---------------------------------------------------------------------------
-// init
-// ---------------------------------------------------------------------------
-/** Derive a contract-valid project slug; init alone needs a non-empty fallback. */
-export function projectSlugFrom(name) {
-    return inferredProjectSlugFrom(name) ?? 'project';
-}
-/** Long enough for a first controlled Companion install; keep-waiting extends another budget. */
-const DEVICE_BRIDGE_TIMEOUT_MS = 10 * 60 * 1000;
-const DEVICE_BRIDGE_POLL_MS = 2_000;
-const PROOF_TIMEOUT_MS = 30_000;
-const PROOF_POLL_MS = 1_000;
-function formatWaitBudget(milliseconds) {
-    const minutes = Math.round(milliseconds / 60_000);
-    return minutes === 1 ? '1 minute' : `${minutes} minutes`;
-}
-async function closeGap(deps, state, flags) {
-    if (state.id === 'project-enablement') {
-        const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
-        const binding = projectBinding(deps.cwd, deps.env, config.project.value);
-        if (binding === null)
-            return 'failed';
-        enableProject(binding);
-        return 'closed';
-    }
-    if (state.id === 'hooks') {
-        const harnesses = await pickHarnessesToInstall(deps);
-        if (harnesses === null || harnesses.length === 0)
-            return 'failed';
-        let ok = true;
-        for (const harness of harnesses) {
-            if (hooksInstallCommand(deps, { harness, narrate: false }) !== EXIT.ok)
-                ok = false;
-        }
-        return ok ? 'closed' : 'failed';
-    }
-    if (state.id === 'hooks-adapter') {
-        const effective = inspectCliInstallations(deps.env, deps.hookPlatform ?? process.platform).effective;
-        if (effective === null || effective.artifact_path === null)
-            return 'failed';
-        try {
-            installHookAdapter({ execPath: process.execPath, scriptPath: effective.artifact_path }, deps.hookAdapterHome, deps.hookPlatform ?? process.platform);
-            return 'closed';
-        }
-        catch (err) {
-            deps.io.err(`Could not retarget Question Routing: ${String(err)}`);
-            return 'failed';
-        }
-    }
-    if (state.id === 'skill') {
-        if (deps.nativeSkills === undefined) {
-            deps.io.err('Skill installation failed — the native `npx skills` flow is unavailable.');
-            return 'failed';
-        }
-        // Refuse rather than guess a release identity. The production adapter uses
-        // this only as a human label; it verifies and stages npm's bundled skill at
-        // a project-relative local path before it invokes the installer.
-        if (SKILLS_SOURCE === null) {
-            deps.io.err('Skill installation failed — this build cannot determine its own version, so there is no release tag to install from.');
-            return 'failed';
-        }
-        const installScope = flags.skillsScope;
-        if (installScope === undefined) {
-            deps.io.err('Skill installation refused — choose a skill scope: `notifai init --skills --skills-scope project` or `... global`.');
-            return 'failed';
-        }
-        const retry = `notifai init --skills --skills-scope ${installScope}`;
-        let inventory = await listScopedNotifaiSkills(deps);
-        if (inventory.errors.length > 0) {
-            deps.io.err(`Could not inspect installed guidance. Retry with \`${retry}\`.`);
-            return 'failed';
-        }
-        const scopesOverlap = () => {
-            const selected = inventory.installed.find((skill) => skill.scope === installScope)?.path
-                ?? conventionalSkillPath(installScope, 'notifai', deps.cwd, deps.env);
-            const normalize = (file) => {
-                const resolved = canonicalPath(file);
-                return (deps.hookPlatform ?? process.platform) === 'win32' ? resolved.toLowerCase() : resolved;
-            };
-            const destination = normalize(selected);
-            return inventory.installed.some((skill) => {
-                if (skill.scope === installScope)
-                    return false;
-                const old = normalize(skill.path);
-                return destination === old || destination.startsWith(`${old}${path.sep}`)
-                    || old.startsWith(`${destination}${path.sep}`);
-            });
-        };
-        const refuseOverlap = () => {
-            deps.io.err('Project and global skill destinations overlap. Keep the existing scope, or run setup from a project with separate skill directories before changing scope.');
-            return 'failed';
-        };
-        if (scopesOverlap())
-            return refuseOverlap();
-        const selectedIsVerified = () => inventory.installed.some((skill) => skill.scope === installScope && installedSkillMatchesPackage(skill));
-        // Keep the existing scope until the native installer has produced a
-        // content-verified replacement. A retry after partial cleanup can reuse
-        // this proof and finish without invoking the installer again.
-        if (!selectedIsVerified()) {
-            deps.io.out(`Starting the native npx skills setup for the notifai agent skill (${installScope} scope)...`);
-            const operation = await deps.nativeSkills.add({
-                source: SKILLS_SOURCE,
-                skill: 'notifai',
-                cwd: deps.cwd,
-                env: deps.env,
-                scope: installScope,
-            }).catch((error) => ({ code: 1, error: String(error) }));
-            const code = typeof operation === 'number' ? operation : operation.code;
-            if (code !== 0) {
-                deps.io.err(typeof operation === 'number'
-                    ? `Skill installation failed. Retry with \`${retry}\` after checking the network connection.`
-                    : `Skill installation refused — ${operation.error}. Retry with \`${retry}\`.`);
-                return 'failed';
-            }
-            inventory = await listScopedNotifaiSkills(deps);
-            if (inventory.errors.length > 0 || !selectedIsVerified()) {
-                deps.io.err(`The selected skill could not be verified; the previous scope was kept. Retry with \`${retry}\`.`);
-                return 'failed';
-            }
-        }
-        const extras = inventory.installed.filter((skill) => skill.scope !== installScope);
-        if (scopesOverlap())
-            return refuseOverlap();
-        for (const extra of extras) {
-            const code = await deps.nativeSkills.remove({
-                skill: 'notifai',
-                scope: extra.scope,
-                cwd: deps.cwd,
-                env: deps.env,
-            }).catch(() => 1);
-            if (code !== 0) {
-                deps.io.err(`The ${installScope} skill is verified, but cleanup of the ${extra.scope} copy failed. Retry with \`${retry}\` to finish.`);
-                return 'failed';
-            }
-        }
-        inventory = await listScopedNotifaiSkills(deps);
-        if (inventory.errors.length > 0 || inventory.installed.length !== 1 || !selectedIsVerified()) {
-            deps.io.err(`Skill migration is incomplete. Retry with \`${retry}\` to finish.`);
-            return 'failed';
-        }
-        return 'closed';
-    }
-    if (state.id === 'proof')
-        return await runSetupProof(deps);
-    return 'failed';
-}
-function deviceBridgeMessage(devices) {
-    if (devices.length === 0) {
-        return 'Waiting for a Companion App to sign in and register…';
-    }
-    const denied = devices.find((device) => device.permission_status === 'denied');
-    if (denied)
-        return `Waiting for notifications to be allowed on ${denied.display_name}…`;
-    const undecided = devices.find((device) => device.permission_status === 'not_determined');
-    if (undecided)
-        return `Waiting for ${undecided.display_name} to allow the notification prompt…`;
-    return 'Waiting for a Companion device to become ready…';
-}
-/** How many Companion Apps this Account has registered, on any platform. */
-async function registeredCompanions(client) {
-    try {
-        const response = await client.listDevices();
-        return response.devices.filter((device) => device.platform === 'ios' || device.platform === 'android').length;
-    }
-    catch {
-        // Unreachable here means unreachable for the wait that follows; ask, so a
-        // User with nothing installed still gets the platform-specific steps.
-        return 0;
-    }
-}
-/**
- * Which phone the notifications should arrive on.
- *
- * Asked in the User's words, here, so the destination this terminal opens is
- * already about their phone rather than an index they have to choose from
- * again on the other screen. This selection is only offered at a human terminal.
- */
-async function askCompanionPlatform(deps) {
-    if (deps.io.interactive !== true || deps.io.select === undefined)
-        return null;
-    const selected = await deps.io.select('Where do you want to receive notifications?', [
-        { value: 'iphone', label: 'iPhone' },
-        { value: 'android', label: 'Android' },
-    ]);
-    return selected === 'iphone' || selected === 'android' ? selected : null;
-}
-/**
- * Observe the supported Device Installation path while the user finishes the
- * app-side work. The bridge is one focused setup destination for the platform
- * they just named — not the omnibus help page, whose own next step is to go
- * somewhere else. Interactive runs open it so the user never types
- * the URL; non-interactive/agent paths only print plain text and never wait on
- * a prompt.
- *
- * The wait budget is stated up front. On expiry we say the *timer* expired —
- * not the setup — and offer another budget when a human is present. Agents
- * never hang: this whole path is gated on `io.interactive`, and keep-waiting
- * uses `confirm` which resolves the safe default when not interactive.
- */
-async function waitForReadyDevice(deps, state) {
-    const remedy = state.remedy;
-    if (deps.io.interactive !== true || remedy?.by !== 'user-elsewhere')
-        return 'pending';
-    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
-    const authed = authedClient(deps, config);
-    if (!authed) {
-        deps.io.err('Could not start the companion-device wait: this machine is not signed in.');
-        return 'failed';
-    }
-    const budgetLabel = formatWaitBudget(DEVICE_BRIDGE_TIMEOUT_MS);
-    // A phone that is registered but silent needs its permission allowed, not
-    // install steps — and asking which phone would be asking about one they are
-    // already holding. Only a User with nothing registered has a platform still
-    // to name, and that is read from the account rather than from the wording of
-    // the state that got us here.
-    const needsPlatform = (await registeredCompanions(authed.client)) === 0;
-    const platform = needsPlatform ? await askCompanionPlatform(deps) : null;
-    if (needsPlatform && platform === null)
-        return 'pending';
-    const setupUrl = setupCompanionUrl(authed.baseUrl, platform ?? undefined);
-    const stepsLabel = platform === null ? 'Setup steps (no typing)' : `${companionPlatformLabel(platform)} steps (no typing)`;
-    await deps.io.note?.([
-        state.detail,
-        remedy.summary,
-        `${stepsLabel}: ${setupUrl}`,
-        `I will wait up to ${budgetLabel} for a Companion App to become ready. Ctrl-C stops this wait.`,
-    ].join('\n'), 'Finish setup on your phone');
-    // The platform choice (or resuming an existing installation) starts the
-    // handoff. Only extending an expired wait needs another decision.
-    deps.io.openUrl(setupUrl);
-    const now = deps.now ?? Date.now;
-    const sleep = deps.sleep ??
-        ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
-    const spinner = await deps.io.spinner?.(`Waiting up to ${budgetLabel} for a Companion device…`);
-    let lastDevices = [];
-    let deadline = now() + DEVICE_BRIDGE_TIMEOUT_MS;
-    for (;;) {
-        while (now() < deadline) {
-            try {
-                const response = await authed.client.listDevices();
-                const companionDevices = response.devices.filter((device) => device.platform === 'ios' || device.platform === 'android');
-                lastDevices = companionDevices;
-                const ready = readyCompanionDevices(companionDevices)[0];
-                if (ready) {
-                    spinner?.stop(`${ready.display_name} is ready to receive`);
-                    return 'closed';
-                }
-                spinner?.message(deviceBridgeMessage(companionDevices));
-            }
-            catch (err) {
-                if (!(err instanceof NetworkError)) {
-                    spinner?.error('Could not check companion readiness');
-                    reportError(deps, err);
-                    return 'failed';
-                }
-                spinner?.message('Connection lost — still watching…');
-            }
-            await sleep(Math.min(DEVICE_BRIDGE_POLL_MS, Math.max(0, deadline - now())));
-        }
-        // Timer expired — setup did not. Offer another budget only when a human
-        // can answer; confirm() already returns the fallback for agents, so this
-        // never hangs unattended even if interactive were mis-set.
-        spinner?.error(`The ${budgetLabel} wait timer expired`);
-        deps.io.err(`The ${budgetLabel} wait timer expired — setup is not finished, only this wait.`);
-        deps.io.err(deviceBridgeMessage(lastDevices).replace(/…$/, '.'));
-        deps.io.err(`Re-run \`notifai init\` later and it will pick up from here (steps: ${setupUrl}).`);
-        const keepWaiting = await deps.io.confirm(`Keep waiting for another ${budgetLabel}?`, false);
-        if (!keepWaiting) {
-            deps.io.out('Stopping the wait. Companion setup can continue; re-run `notifai init` when ready.');
-            return 'pending';
-        }
-        spinner?.message(`Waiting another ${budgetLabel} for a Companion App…`);
-        deadline = now() + DEVICE_BRIDGE_TIMEOUT_MS;
-    }
-}
-/**
- * The notification that says a machine is set up — sent once per Approved
- * Machine, never per Project, so it only ever arrives when setup actually
- * finished somewhere new.
- *
- * It names the machine because that is the news: the User may run agents on
- * several, and "your agents can reach you" from one they set up weeks ago
- * reads as a mystery rather than a milestone. It carries no Project, because
- * nothing about it is Project-specific. It arrives the way their
- * notifications will: `done` is the honest kind, and it lets the server pick
- * the sound through its own kind and Account layers instead of this command
- * stamping one.
- */
-function setupProofDraft(config, machineName, device) {
-    return buildDraft(config, {
-        projectless: true,
-        title: `${machineName} is set up`,
-        summary: `Agents on ${machineName} can now send you notifications. They will arrive like this one.`,
-        kind: 'done',
-        platform: device.platform,
-        device: [device.device_id],
-        // Noticeable, not intrusive: a normal banner and sound. Deliberately not
-        // `time_sensitive` — a setup confirmation has no business breaking a Focus.
-        //
-        // Android has no caller-selected interruption level. Explicit null keeps an
-        // Apple preference in config from leaking into this Android-only proof.
-        level: device.platform === 'ios' ? 'active' : null,
-        collapseKey: 'notifai-setup-verification',
-    });
-}
-async function submitSetupProof(deps, client, config, device) {
-    const machineName = deps.store.load()?.machineName ?? 'This computer';
-    const build = setupProofDraft(config, machineName, device);
-    if (!build.ok) {
-        deps.io.err(`Could not build the setup verification notification: ${build.error}`);
-        return null;
-    }
-    const capabilities = CAPABILITIES_V1.describe(build.platform);
-    if (!capabilities) {
-        deps.io.err(`No capability contract is available for ${build.platform}.`);
-        return null;
-    }
-    const validation = validateDraft(build.draft, capabilities);
-    if (!validation.ok) {
-        for (const issue of validation.errors) {
-            deps.io.err(`Setup verification ${issue.path}: ${issue.message}`);
-        }
-        return null;
-    }
-    try {
-        return await client.submit({
-            idempotency_key: `init-${randomBytes(12).toString('base64url')}`,
-            draft: build.draft,
-        }, config.wait_seconds.value);
-    }
-    catch (err) {
-        reportError(deps, err);
-        return null;
-    }
-}
-/**
- * Send or resume one real setup probe, then wait for a Companion Receipt.
- * Provider Acceptance is intentionally insufficient: it proves a push provider
- * accepted the request, not that a companion process received it.
- */
-async function runSetupProof(deps) {
-    const config = loadLoggedConfig(deps, { cwd: deps.cwd, env: deps.env });
-    const authed = authedClient(deps, config);
-    if (!authed)
-        return 'failed';
-    let devices;
-    try {
-        devices = (await authed.client.listDevices()).devices;
-    }
-    catch (err) {
-        reportError(deps, err);
-        return 'failed';
-    }
-    const candidates = readyCompanionDevices(devices);
-    const existing = readSetupProof(deps);
-    // An observed receipt proved this machine; setup never sends again.
-    if (existing?.companion_receipt.state === 'observed')
-        return 'closed';
-    const existingApplies = setupProofApplies(existing, candidates.map((device) => device.device_id));
-    const target = (existingApplies
-        ? candidates.find((device) => device.device_id === existing.device_id)
-        : undefined) ?? candidates[0];
-    if (!target) {
-        deps.io.err('Setup proof needs a receipt-capable iPhone or Android Companion App.');
-        return 'pending';
-    }
-    let proof = existingApplies && existing.device_id === target.device_id
-        ? existing
-        : null;
-    const nowMs = (deps.now ?? Date.now)();
-    if (proof !== null && setupProofIsStale(proof, nowMs)) {
-        let keepStale = false;
-        try {
-            const snapshot = await authed.client.evidence(proof.request_id);
-            keepStale = observedCompanionReceipt(snapshot, proof.device_id) !== null;
-        }
-        catch (err) {
-            if (!(err instanceof ApiCallError && err.code === 'not_found')) {
-                // Unavailable evidence cannot establish that the saved request needs replacing.
-                reportError(deps, err);
-                return 'failed';
-            }
-        }
-        if (!keepStale) {
-            deps.io.out(`The saved proof ${proof.request_id} is older than 24h without a Companion Receipt; sending a replacement.`);
-            proof = null;
-        }
-    }
-    if (proof === null) {
-        const receipt = await submitSetupProof(deps, authed.client, config, target);
-        if (receipt === null)
-            return 'failed';
-        if (receipt.overall === 'provider_rejected_all') {
-            deps.io.err(formatReceipt(receipt));
-            return 'failed';
-        }
-        proof = {
-            request_id: receipt.request_id,
-            device_id: target.device_id,
-            started_at: new Date((deps.now ?? Date.now)()).toISOString(),
-            companion_receipt: { state: 'unknown', observed_at: null },
-        };
-        if (!writeSetupProof(deps, proof))
-            return 'failed';
-        deps.io.out(`Verification notification sent to ${target.display_name} (${proof.request_id}).`);
-    }
-    else {
-        deps.io.out(`Checking verification notification ${proof.request_id} again.`);
-    }
-    const now = deps.now ?? Date.now;
-    const sleep = deps.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
-    const deadline = now() + PROOF_TIMEOUT_MS;
-    const spinner = deps.io.interactive === true
-        ? await deps.io.spinner?.("Waiting for a Companion Receipt (the app's delivery confirmation)…")
-        : null;
-    let lastError = null;
-    let replacedMissingProof = false;
-    for (;;) {
-        try {
-            const snapshot = await authed.client.evidence(proof.request_id);
-            const observed = observedCompanionReceipt(snapshot, proof.device_id);
-            if (observed) {
-                if (!writeSetupProof(deps, observedSetupProof(proof, observed.observedAt))) {
-                    spinner?.error('Could not save the observed Companion Receipt');
-                    return 'failed';
-                }
-                spinner?.stop(`Receipt observed from ${observed.delivery.device_name}`);
-                deps.io.out(`Companion Receipt (the app's delivery confirmation) observed from ${observed.delivery.device_name}.`);
-                return 'closed';
-            }
-            lastError = null;
-        }
-        catch (err) {
-            lastError = err;
-            if (err instanceof ApiCallError &&
-                err.code === 'not_found' &&
-                !replacedMissingProof) {
-                const receipt = await submitSetupProof(deps, authed.client, config, target);
-                if (receipt === null)
-                    return 'failed';
-                if (receipt.overall === 'provider_rejected_all') {
-                    deps.io.err(formatReceipt(receipt));
-                    return 'failed';
-                }
-                proof = {
-                    request_id: receipt.request_id,
-                    device_id: target.device_id,
-                    started_at: new Date(now()).toISOString(),
-                    companion_receipt: { state: 'unknown', observed_at: null },
-                };
-                if (!writeSetupProof(deps, proof))
-                    return 'failed';
-                replacedMissingProof = true;
-                lastError = null;
-                deps.io.out(`The saved proof had expired; sent replacement ${proof.request_id}.`);
-                continue;
-            }
-            if (!(err instanceof NetworkError)) {
-                spinner?.error('Could not read Companion Receipt evidence');
-                reportError(deps, err);
-                return 'failed';
-            }
-            spinner?.message('Connection lost — still checking the same request…');
-        }
-        if (now() >= deadline)
-            break;
-        await sleep(Math.min(PROOF_POLL_MS, Math.max(0, deadline - now())));
-    }
-    spinner?.stop('Delivery confirmation not observed yet');
-    if (lastError instanceof NetworkError)
-        deps.io.err(lastError.message);
-    deps.io.out(`Provider accepted the notification; Companion Receipt (the app's delivery confirmation) for ${proof.request_id} was not observed within ${PROOF_TIMEOUT_MS / 1000}s. ` +
-        'Proof may still arrive — re-run `notifai init` and it will re-check this same notification.');
-    return 'pending';
-}
-/** Closing a local gap cannot have changed the service, the keychain, or devices. */
-function refreshAfterClose(id) {
-    return id === 'project-enablement' || id === 'hooks' || id.startsWith('hooks-') || id === 'skill' || id === 'question-routing-settings'
-        ? ['local']
-        : undefined;
-}
-/** Whether an optional gap should be closed, given flags and who is watching. */
-function wantsOptional(deps, state, flags) {
-    // Optional CLI updates are surfaced by doctor or when a missing feature is
-    // relevant. Init does not turn them into setup work.
-    if (state.id === 'contract')
-        return Promise.resolve(false);
-    if (state.id === 'project')
-        return Promise.resolve(false);
-    if (state.id === 'project-enablement')
-        return Promise.resolve(true);
-    // Every other hook sub-state is a report line about routing, not an errand
-    // with a yes/no question of its own; offering the hooks question for one of
-    // them would ask about something the answer does not change.
-    if (state.id !== 'hooks' && state.id !== 'skill')
-        return Promise.resolve(false);
-    const explicit = state.id === 'hooks' ? flags.hooks : flags.skills;
-    if (explicit !== undefined)
-        return Promise.resolve(explicit);
-    // An agent is never asked, and never assumed into a change it did not
-    // request: silence means no, and the summary says what was skipped.
-    if (deps.io.interactive !== true)
-        return Promise.resolve(false);
-    const question = state.id === 'hooks'
-        ? 'Install harness hooks, so questions reach your devices when you are away?'
-        : 'Install/update the agent guidance skill through the native npx skills flow?';
-    return deps.io.confirm(question, true);
-}
-/** The one state whose remedy places files a scope choice is about. */
-function needsSkillScope(state) {
-    return state.id === 'skill';
-}
-function isSkillScope(value) {
-    return value === 'project' || value === 'global';
-}
-/**
- * Skill-scope flags are checked before anything runs, because a contradiction
- * is a usage error and reporting it after half a setup is worse than reporting
- * it now. Answering the question is a separate step (`scopeForSkillInstall`).
- *
- * Lifecycle wiring has no scope: it is installed for this machine, and whether
- * it does anything in a Project is Project Enablement's question.
- */
-function checkSkillScopeFlags(deps, flags) {
-    if (flags.skillsScope !== undefined && !isSkillScope(flags.skillsScope)) {
-        deps.io.err('Invalid skill scope. Choose `project` or `global`.');
-        return 'usage';
-    }
-    if (flags.skillsScope !== undefined && flags.skills !== true) {
-        deps.io.err('`--skills-scope` requires `--skills`.');
-        return 'usage';
-    }
-    // Asking for an install nobody can be asked about is a usage error, and it
-    // is knowable from the flags alone — so it is reported before a setup runs
-    // half way rather than after.
-    if (flags.skillsScope === undefined && deps.io.interactive !== true && flags.skills === true) {
-        deps.io.err('Unattended skill installation requires an explicit scope: pass `--skills-scope project` or `--skills-scope global`.');
-        return 'usage';
-    }
-    return flags.skillsScope;
-}
-/**
- * Where the agent guidance skill should land, asked at the moment it is about
- * to be installed and not before.
- *
- * It used to be the first thing the product ever said, as one question
- * covering skill, hook and shared-config placement, put to someone who had met
- * none of those words. Hooks and config no longer have a scope at all, and
- * what remains belongs to `npx skills`.
- */
-async function scopeForSkillInstall(deps, flags) {
-    if (flags.skillsScope !== undefined)
-        return flags.skillsScope;
-    if (deps.io.interactive === true && deps.io.select) {
-        const selected = await deps.io.select('Should the agent guidance skill be installed for this project only, or for every project on this machine?', [
-            {
-                value: 'project',
-                label: 'This project',
-                hint: 'the skill stays in this checkout',
-            },
-            {
-                value: 'global',
-                label: 'This machine',
-                hint: 'the skill follows you into every repo',
-            },
-        ]);
-        if (selected === 'project' || selected === 'global')
-            return selected;
-        deps.io.err('No skill scope selected. Pass `--skills-scope project` or `--skills-scope global`.');
-        return 'declined';
-    }
-    deps.io.err('Unattended skill installation requires an explicit scope: pass `--skills-scope project` or `--skills-scope global`.');
-    return 'declined';
-}
-/**
- * Setup as one step at a time.
- *
- * The old version ran five steps in a fixed order and ended with a list of
- * everything still outstanding. That is a report, and a report is the wrong
- * output here: someone handed five things to do does none of them, and the
- * order was the script's rather than the dependency graph's — it offered to
- * install hooks after a sign-in that had just failed.
- *
- * So this closes what it can, then surfaces exactly one thing, the first that
- * stands in the way. Re-running advances by one. Idempotence stops being a
- * property to preserve and becomes the mechanism: every decision is derived
- * from observed state, so a partial run, a second project, a fresh worktree
- * and a revoked credential are the same code path arriving at different
- * states rather than four branches to enumerate.
- */
-export async function initCommand(deps, flags) {
-    const workingDeps = flags.json === true
-        ? {
-            ...deps,
-            io: {
-                interactive: false,
-                out: (line) => deps.io.err(line),
-                err: (line) => deps.io.err(line),
-                confirm: async () => false,
-                openUrl: (url) => deps.io.openUrl(url),
-            },
-        }
-        : deps;
-    const scopeFromFlags = checkSkillScopeFlags(workingDeps, flags);
-    if (scopeFromFlags === 'usage')
-        return EXIT.usage;
-    let resolved = { ...flags };
-    await workingDeps.io.intro?.('Notifai setup');
-    // Project inference is the default and writes nothing. An explicit id is a
-    // deliberate shared repository override, authored in this checkout so Git
-    // can review and merge it like every other tracked project policy change.
-    if (resolved.projectId !== undefined) {
-        const configPath = sharedProjectConfigPath(workingDeps.cwd);
-        const existing = existsSync(configPath)
-            ? parseToml(readFileSync(configPath, 'utf8'))
-            : {};
-        existing['project'] = projectSlugFrom(resolved.projectId);
-        mkdirSync(path.dirname(configPath), { recursive: true });
-        writeFileSync(configPath, `${stringifyToml(existing)}\n`);
-    }
-    const skillOpts = () => resolved.skillsScope === undefined ? {} : { skillScope: resolved.skillsScope };
-    let readiness = await assessReadiness(workingDeps, { ...skillOpts(), ...(flags.json === true ? { json: true } : {}) });
-    const reassess = (refresh) => assessReadiness(workingDeps, {
-        ...skillOpts(),
-        ...(flags.json === true ? { json: true } : {}),
-        ...(refresh === undefined ? {} : { previous: readiness, refresh }),
-    });
-    let failed = false;
-    // What actually stopped a sign-in, when something did. Without it the close
-    // renders the state as it was before the attempt — "not paired … run
-    // `notifai init`" — which contradicts the correct line printed moments
-    // earlier and sends the reader back into the command that just failed.
-    let loginBlocker = null;
-    const attempted = new Set();
-    // Re-assess after every successful action. This is how a browser approval or
-    // companion registration can unlock the next state while the user is still
-    // here, without copying the dependency graph into a second setup script.
-    for (;;) {
-        let advanced = false;
-        let stop = false;
-        for (const state of readiness.states) {
-            if (state.status === 'ready')
-                continue;
-            // Question Routing is optional automation, so it is reported and never
-            // waited on. `doctor` still fails on a broken route; `init` walks past
-            // it, because a hook diagnostic standing in front of the delivery proof
-            // means a setup that can already send never proves that it can.
-            const optional = isOptionalSetup(state.id);
-            const halt = () => {
-                if (!optional)
-                    stop = true;
-                return !optional;
-            };
-            if (state.status === 'unknown') {
-                if (halt())
-                    break;
-                continue;
-            }
-            const remedy = state.remedy;
-            if (remedy === undefined || attempted.has(state.id)) {
-                if (state.status === 'gap' && halt())
-                    break;
-                continue;
-            }
-            if (state.status === 'optional-gap') {
-                if (remedy.by !== 'cli' || !(await wantsOptional(workingDeps, state, resolved)))
-                    continue;
-                if (needsSkillScope(state)) {
-                    const scope = await scopeForSkillInstall(workingDeps, resolved);
-                    if (scope === 'declined') {
-                        attempted.add(state.id);
-                        continue;
-                    }
-                    resolved = { ...resolved, skillsScope: scope };
-                }
-                attempted.add(state.id);
-                const result = await closeGap(workingDeps, state, resolved);
-                if (result === 'failed')
-                    failed = true;
-                if (result === 'failed' && state.status === 'optional-gap') {
-                    readiness = await reassess(refreshAfterClose(state.id));
-                    advanced = true;
-                    break;
-                }
-                if (result !== 'closed') {
-                    if (halt())
-                        break;
-                    continue;
-                }
-                readiness = await reassess(refreshAfterClose(state.id));
-                advanced = true;
-                break;
-            }
-            if (remedy.by === 'cli') {
-                if (needsSkillScope(state)) {
-                    const scope = await scopeForSkillInstall(workingDeps, resolved);
-                    if (scope === 'declined') {
-                        attempted.add(state.id);
-                        if (halt())
-                            break;
-                        continue;
-                    }
-                    resolved = { ...resolved, skillsScope: scope };
-                }
-                attempted.add(state.id);
-                const result = await closeGap(workingDeps, state, resolved);
-                if (result === 'failed')
-                    failed = true;
-                if (result === 'failed' && state.id === 'skill') {
-                    readiness = await reassess(refreshAfterClose(state.id));
-                    advanced = true;
-                    break;
-                }
-                if (result !== 'closed') {
-                    if (halt())
-                        break;
-                    continue;
-                }
-                readiness = await reassess(refreshAfterClose(state.id));
-                advanced = true;
-                break;
-            }
-            // The CLI starts approval; the User completes it in their browser.
-            // Both human and unattended init use the same bounded approval flow.
-            if ((state.id === 'credential' || state.id === 'auth') &&
-                remedy.by === 'user-here' &&
-                remedy.interactive === true) {
-                attempted.add(state.id);
-                workingDeps.io.out(workingDeps.io.interactive === true
-                    ? 'Connect this computer — Ctrl-C to stop.'
-                    : 'Starting computer approval.');
-                const loginResult = await loginCommand(workingDeps, { ...(resolved.approval ? { approval: resolved.approval } : {}), ...(resolved.approvalEmail ? { approvalEmail: resolved.approvalEmail } : {}) }, (blocker) => {
-                    loginBlocker = blocker;
-                    // Both renderers must report what actually stopped approval: the
-                    // access errand when the Account has none, or the approval still
-                    // waiting in the browser — never the missing credential observed
-                    // before the attempt began.
-                    readiness = {
-                        states: readiness.states.map((observed) => observed.id === blocker.id
-                            ? blocker
-                            : blocker.id === 'auth' && observed.id === 'credential'
-                                ? { id: 'credential', title: 'This machine', status: 'unknown', detail: 'approval stopped before a machine credential was stored' }
-                                : observed),
-                    };
-                });
-                if (loginResult !== EXIT.ok) {
-                    failed = true;
-                    stop = true;
-                    break;
-                }
-                readiness = await reassess();
-                advanced = true;
-                break;
-            }
-            if (state.id === 'devices' &&
-                remedy.by === 'user-elsewhere' &&
-                workingDeps.io.interactive === true) {
-                attempted.add(state.id);
-                const result = await waitForReadyDevice(workingDeps, state);
-                if (result === 'failed')
-                    failed = true;
-                if (result !== 'closed') {
-                    stop = true;
-                    break;
-                }
-                readiness = await reassess();
-                advanced = true;
-                break;
-            }
-            // A human-only remedy is the first blocker for an unattended agent.
-            if (halt())
-                break;
-            continue;
-        }
-        if (stop || !advanced)
-            break;
-    }
-    const blocker = loginBlocker ?? firstRequiredBlocker(readiness);
-    if (flags.json === true)
-        deps.io.out(JSON.stringify(readinessJson(readiness), null, 2));
-    else
-        await printInitClose(deps, readiness, resolved, loginBlocker);
-    if (blocker === null)
-        return failed ? EXIT.failed : EXIT.ok;
-    return failed || workingDeps.io.interactive !== true ? EXIT.failed : EXIT.ok;
-}
-function leftoverOptionals(readiness, flags) {
-    return readiness.states.filter((state) => {
-        if (state.status !== 'optional-gap')
-            return false;
-        if (isOptionalAutomation(state.id))
-            return false;
-        // Not an install anyone declined, so "Optional, not set up" would misread
-        // it; it gets its own line below.
-        if (state.id === 'cli-bin')
-            return false;
-        if (state.id === 'skill' && flags.skills === false)
-            return false;
-        return true;
-    });
-}
-/**
- * A `notifai` the reader cannot type.
- *
- * Said on the way out of every run, successful or not, because every next step
- * this command prints — here, in the skill, in the README — names a command
- * that will not be found until it is fixed.
- */
-function printMissingCliBin(deps, readiness) {
-    const state = readiness.states.find((candidate) => candidate.id === 'cli-bin');
-    if (state?.status !== 'optional-gap')
-        return;
-    deps.io.out(`Heads up: ${state.detail}. ${remedyLine(state)}`);
-}
-function printOptionalLeftovers(deps, leftovers) {
-    for (const state of leftovers) {
-        deps.io.out(`Optional, not set up — ${remedyLine(state)}`);
-    }
-}
-async function printInitClose(deps, readiness, flags, stoppedBy = null) {
-    const blocker = stoppedBy ?? firstRequiredBlocker(readiness);
-    const canSend = readiness.states.find((state) => state.id === 'devices')?.status === 'ready';
-    const questions = questionRoutingReady(readiness);
-    const leftovers = leftoverOptionals(readiness, flags).filter((state) => state.id !== 'contract');
-    if (blocker?.id === 'contract') {
-        deps.io.out(blocker.detail);
-        deps.io.out(blocker.remedy?.by !== 'user-elsewhere' && blocker.remedy?.command !== undefined
-            ? blocker.remedy.command
-            : updateCliCommand(deps));
-        return;
-    }
-    printMissingCliBin(deps, readiness);
-    if (deps.io.interactive === true) {
-        if (blocker === null) {
-            const lines = [
-                canSend ? 'You can send notifications.' : 'You are signed in.',
-                questions
-                    ? 'Questions will reach your devices.'
-                    : 'Questions are terminal-only until Question Routing is ready.',
-            ];
-            await deps.io.note?.(lines.join('\n'), 'Ready');
-            printOptionalLeftovers(deps, leftovers);
-            deps.io.out(questions
-                ? 'All set. Agents in this project can notify you and ask you questions.'
-                : 'All set. Agents in this project can notify you. Questions are terminal-only until Question Routing is ready.');
-            await deps.io.outro?.('All set ✨');
-            return;
-        }
-        // No framed copy of what the next three lines already say. The "Ready"
-        // note above adds something the close does not; this one only made a
-        // stopped visit state its one step twice, box then text.
-        deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`);
-        deps.io.out(`  ${remedyLine(blocker)}`);
-        if (shouldRestateInit(blocker)) {
-            deps.io.out(`  Then re-run \`${SETUP_COMMAND}\` and it will pick up from here.`);
-        }
-        await deps.io.outro?.('One step remains (above)');
-        return;
-    }
-    if (blocker === null) {
-        printOptionalLeftovers(deps, leftovers);
-        deps.io.out(questions
-            ? 'All set. Agents in this project can notify you and ask you questions.'
-            : 'All set. Agents in this project can notify you. Questions are terminal-only until Question Routing is ready.');
-        return;
-    }
-    deps.io.out(`Next: ${blocker.title} — ${blocker.detail}`);
-    deps.io.out(`  ${remedyLine(blocker)}`);
-    if (shouldRestateInit(blocker)) {
-        deps.io.out(`  Then re-run \`${SETUP_COMMAND}\` and it will pick up from here.`);
-    }
-}
-function shouldRestateInit(blocker) {
-    if (blocker.remedy?.by !== 'user-elsewhere' && blocker.remedy?.by !== 'user-here')
-        return false;
-    return !('command' in blocker.remedy) || blocker.remedy.command !== SETUP_COMMAND;
-}
-//# sourceMappingURL=commands-init.js.map