crewly 1.20.181 → 1.20.182

package/dist/cli/backend/src/services/runtime-terms/runtime-terms-consent.service.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Owner consent for a runtime's first-run Terms of Service.
+ *
+ * The harness never accepts third-party terms on its own. When a runtime's
+ * Terms screen is seen (on launch, by the smoke test, or on a probe), ONE
+ * decision card per runtime per machine goes to the owner's DM with this
+ * machine's orc bot: "Agree, no data sharing" / "Agree + share data" /
+ * "Don't agree", 24 h, default Don't agree. On the answer:
+ *
+ * - agree: launch the runtime in a dedicated PTY session, drive its setup
+ *   screens to the choice (data box verified on screen before Done), check
+ *   the prompt appears, close the session, run the runtime smoke test and
+ *   report both in the card's thread;
+ * - don't agree (or no answer): mark the runtime "terms not accepted" so the
+ *   fallback order skips it (reason shown in Settings → Runtimes); asked
+ *   again only when the owner presses Test, re-adds it, or Accept terms….
+ *
+ * specs/2026-10-01-runtime-terms-consent.md
+ *
+ * @module services/runtime-terms/runtime-terms-consent.service
+ */
+import type { OwnerDecision } from '../../types/decision.types.js';
+import { type ComponentLogger } from '../core/logger.service.js';
+import type { SystemAskInput } from '../decisions/decision.service.js';
+import type { SmokeTestResult } from '../runtime-fallback/runtime-smoke-test.service.js';
+import type { TermsDriveResult, TermsTerminal } from './antigravity-terms-driver.js';
+import type { RuntimeTermsRecord, RuntimeTermsStore } from './runtime-terms.store.js';
+/** The owner's three answers. */
+export type TermsChoice = 'agree_no_data' | 'agree_share_data' | 'decline';
+/** Card text of a runtime. */
+export interface TermsCardText {
+    title: string;
+    question: string;
+    body: string[];
+}
+/** What Settings shows next to the inline choices. */
+export interface TermsInfo {
+    /** One plain-English sentence on what is asked */
+    summary: string;
+    /** The pre-checked data-sharing item, verbatim */
+    dataItem: string;
+    links: Array<{
+        label: string;
+        url: string;
+    }>;
+}
+/** What the service knows about one runtime's Terms screens. */
+export interface RuntimeTermsProfile {
+    runtime: string;
+    label: string;
+    info: TermsInfo;
+    /** Card text for this machine */
+    card(machine: string): TermsCardText;
+    /** Drive the setup screens of a freshly launched runtime */
+    drive(term: TermsTerminal, shareData: boolean): Promise<TermsDriveResult>;
+    /** What a screen shows: the Terms / setup screens, the ready prompt, a refusal, or not yet known */
+    classify(screen: string): 'terms' | 'ready' | 'blocked' | 'unknown';
+}
+/** Result of {@link RuntimeTermsConsentService.probe}. */
+export interface TermsProbeResult {
+    outcome: 'terms' | 'ready' | 'blocked' | 'unknown';
+    record: RuntimeTermsRecord | null;
+    /** Screen text at the end (secrets redacted) */
+    screen: string;
+}
+/** A launched dedicated session. */
+export interface TermsSession {
+    terminal: TermsTerminal;
+    /** Leave the runtime and kill the session (always called) */
+    close(): Promise<void>;
+}
+/** The decision-card calls used. */
+export interface TermsDecisionApi {
+    askSystem(input: SystemAskInput): Promise<OwnerDecision>;
+    get(id: string): Promise<OwnerDecision | null>;
+    chooseFromDashboard(id: string, optionKey: string): Promise<OwnerDecision>;
+    replyInThread(id: string, text: string): Promise<boolean>;
+}
+/** Dependencies. */
+export interface RuntimeTermsDeps {
+    store: RuntimeTermsStore;
+    decisions: () => TermsDecisionApi | null;
+    profiles: Record<string, RuntimeTermsProfile>;
+    /** Launch the runtime in the harness's dedicated session */
+    launch: (runtime: string) => Promise<TermsSession>;
+    /** Kill the dedicated session if it is running (Don't agree) */
+    closeSession?: (runtime: string) => Promise<void>;
+    runSmokeTest: (runtime: string) => Promise<SmokeTestResult>;
+    machineName: () => string;
+    /** A runtime's consent changed (availability caches) */
+    onChange?: (runtime: string) => void;
+    now?: () => Date;
+    sleep?: (ms: number) => Promise<void>;
+    /** How long a probe waits for a recognisable screen */
+    probeTimeoutMs?: number;
+    logger?: ComponentLogger;
+}
+/** How a report was triggered. */
+export interface TermsReport {
+    /** launch | smoke_test | probe | settings | chain */
+    source: string;
+    /** The owner asked (Test, Accept terms…, re-added): re-ask even after Don't agree */
+    ownerInitiated?: boolean;
+}
+/** A runtime's Terms state as the API shows it. */
+export interface RuntimeTermsView extends Omit<RuntimeTermsRecord, 'status' | 'updatedAt'> {
+    /** `none` = never seen a Terms screen on this machine */
+    status: RuntimeTermsRecord['status'] | 'none';
+    updatedAt?: string;
+    label: string;
+    info: TermsInfo;
+    /** Why the runtime is skipped, when it is */
+    blockedReason: string | null;
+    /** Choices the inline Settings action offers */
+    choices: Array<{
+        choice: TermsChoice;
+        label: string;
+    }>;
+}
+/** Choice ↔ button label. */
+export declare const TERMS_CHOICE_LABELS: Readonly<Record<TermsChoice, string>>;
+/**
+ * The choice an option label means.
+ *
+ * @param label - Button label
+ * @returns Choice, or null
+ */
+export declare function choiceOfLabel(label: string | undefined): TermsChoice | null;
+/**
+ * Screen text for a Slack code block: secrets redacted, last lines only, no
+ * fence breakers.
+ *
+ * @param screen - Screen text
+ * @returns Block text
+ */
+export declare function screenForThread(screen: string): string;
+/** The service. */
+export declare class RuntimeTermsConsentService {
+    private readonly deps;
+    private readonly logger;
+    private readonly now;
+    /** Serialises asks per runtime (launch + smoke test can report at once) */
+    private readonly asking;
+    /** Running accept / decline per runtime */
+    private readonly running;
+    /**
+     * @param deps - Dependencies
+     */
+    constructor(deps: RuntimeTermsDeps);
+    /**
+     * Whether the service handles a runtime.
+     *
+     * @param runtime - Runtime id
+     * @returns True when it has a profile
+     */
+    supports(runtime: string): boolean;
+    /**
+     * A runtime's Terms screen was seen: ask the owner, once.
+     *
+     * No new card while one is open or the harness is accepting; none after
+     * Don't agree / a failed attempt unless the owner asked
+     * (`ownerInitiated`).
+     *
+     * @param runtime - Runtime id
+     * @param report - Source
+     * @returns The record, or null for a runtime without a profile
+     */
+    reportTermsScreen(runtime: string, report: TermsReport): Promise<RuntimeTermsRecord | null>;
+    /**
+     * Settings → Runtimes → Accept terms…: post the card (or return the open one).
+     *
+     * @param runtime - Runtime id
+     * @returns The record
+     * @throws Error for a runtime without Terms handling
+     */
+    requestConsent(runtime: string): Promise<RuntimeTermsRecord>;
+    /**
+     * Probe: launch the runtime in the dedicated session, read (never press
+     * anything) until the screen is recognisable, close it. A Terms screen
+     * asks the owner (the owner asked for the check); a ready prompt means
+     * the Terms were accepted here already (e.g. in a terminal).
+     *
+     * @param runtime - Runtime id
+     * @returns What was on screen and the record after
+     * @throws Error while an answer is being applied, or for a runtime without a profile
+     */
+    probe(runtime: string): Promise<TermsProbeResult>;
+    /**
+     * Answer inline from Settings: through the open card when there is one
+     * (so the card updates), else directly.
+     *
+     * @param runtime - Runtime id
+     * @param choice - Owner's choice
+     * @returns The record after the answer was taken (driving continues in the background)
+     */
+    answer(runtime: string, choice: TermsChoice): Promise<RuntimeTermsRecord>;
+    /**
+     * The `runtime_terms` decision-kind handler
+     * (`DecisionService.registerKindHandler`): acts on the answer. No agent
+     * asked, so there is no note for one.
+     *
+     * @param d - Settled decision
+     * @returns null (nothing to deliver)
+     */
+    onSettled(d: OwnerDecision): Promise<null>;
+    /**
+     * A decision was settled: act on runtime-terms ones.
+     *
+     * @param d - Settled decision
+     */
+    handleSettled(d: OwnerDecision): void;
+    /**
+     * Why a runtime cannot be used because of its Terms (null = it can).
+     *
+     * @param runtime - Runtime id
+     * @returns Owner-facing reason, or null
+     */
+    blockedReason(runtime: string): string | null;
+    /** @returns Every runtime with a Terms flow, with its record */
+    list(): RuntimeTermsView[];
+    /**
+     * Wait for a running accept / decline (tests, the API's `?wait=1`).
+     *
+     * @param runtime - Runtime id
+     */
+    whenIdle(runtime: string): Promise<void>;
+    private askOnce;
+    private start;
+    private decline;
+    private accept;
+    private reply;
+    private save;
+}
+/** @returns The backend's instance, or null before wiring (and in tests) */
+export declare function getRuntimeTermsConsentService(): RuntimeTermsConsentService | null;
+/** @param service - Instance to install (null clears) */
+export declare function setRuntimeTermsConsentService(service: RuntimeTermsConsentService | null): void;
+/**
+ * Report a Terms screen to the backend's service, when wired (fire and forget).
+ *
+ * @param runtime - Runtime id
+ * @param report - Source
+ */
+export declare function reportRuntimeTermsScreen(runtime: string, report: TermsReport): void;
+//# sourceMappingURL=runtime-terms-consent.service.d.ts.map

package/dist/cli/backend/src/services/runtime-terms/runtime-terms-consent.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-terms-consent.service.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/runtime-terms/runtime-terms-consent.service.ts"],"names":[],"mappings":"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"}

package/dist/cli/backend/src/services/runtime-terms/runtime-terms-consent.service.js

@@ -0,0 +1,428 @@
+/**
+ * Owner consent for a runtime's first-run Terms of Service.
+ *
+ * The harness never accepts third-party terms on its own. When a runtime's
+ * Terms screen is seen (on launch, by the smoke test, or on a probe), ONE
+ * decision card per runtime per machine goes to the owner's DM with this
+ * machine's orc bot: "Agree, no data sharing" / "Agree + share data" /
+ * "Don't agree", 24 h, default Don't agree. On the answer:
+ *
+ * - agree: launch the runtime in a dedicated PTY session, drive its setup
+ *   screens to the choice (data box verified on screen before Done), check
+ *   the prompt appears, close the session, run the runtime smoke test and
+ *   report both in the card's thread;
+ * - don't agree (or no answer): mark the runtime "terms not accepted" so the
+ *   fallback order skips it (reason shown in Settings → Runtimes); asked
+ *   again only when the owner presses Test, re-adds it, or Accept terms….
+ *
+ * specs/2026-10-01-runtime-terms-consent.md
+ *
+ * @module services/runtime-terms/runtime-terms-consent.service
+ */
+import { RUNTIME_TERMS_CONSTANTS } from '../../constants.js';
+import { LoggerService } from '../core/logger.service.js';
+import { PENDING_DECISION_STATUSES } from '../decisions/decision-store.js';
+import { redactSecrets } from '../harness/login-rules.js';
+const C = RUNTIME_TERMS_CONSTANTS;
+/** Choice ↔ button label. */
+export const TERMS_CHOICE_LABELS = {
+    agree_no_data: C.OPTIONS.AGREE_NO_DATA,
+    agree_share_data: C.OPTIONS.AGREE_SHARE_DATA,
+    decline: C.OPTIONS.DECLINE,
+};
+/**
+ * The choice an option label means.
+ *
+ * @param label - Button label
+ * @returns Choice, or null
+ */
+export function choiceOfLabel(label) {
+    const entry = Object.entries(TERMS_CHOICE_LABELS).find(([, l]) => l === label);
+    return entry ? entry[0] : null;
+}
+/**
+ * Screen text for a Slack code block: secrets redacted, last lines only, no
+ * fence breakers.
+ *
+ * @param screen - Screen text
+ * @returns Block text
+ */
+export function screenForThread(screen) {
+    const lines = redactSecrets(screen)
+        .split('\n')
+        .map((l) => l.replace(/\s+$/, ''));
+    while (lines.length && !lines[lines.length - 1])
+        lines.pop();
+    const tail = lines.slice(-C.DRIVE.SCREEN_LINES_IN_THREAD).join('\n').replace(/```/g, "'''");
+    return '```\n' + (tail || '(empty screen)') + '\n```';
+}
+/** The service. */
+export class RuntimeTermsConsentService {
+    deps;
+    logger;
+    now;
+    /** Serialises asks per runtime (launch + smoke test can report at once) */
+    asking = new Map();
+    /** Running accept / decline per runtime */
+    running = new Map();
+    /**
+     * @param deps - Dependencies
+     */
+    constructor(deps) {
+        this.deps = deps;
+        this.logger = deps.logger ?? LoggerService.getInstance().createComponentLogger('RuntimeTerms');
+        this.now = deps.now ?? (() => new Date());
+    }
+    /**
+     * Whether the service handles a runtime.
+     *
+     * @param runtime - Runtime id
+     * @returns True when it has a profile
+     */
+    supports(runtime) {
+        return Boolean(this.deps.profiles[runtime]);
+    }
+    /**
+     * A runtime's Terms screen was seen: ask the owner, once.
+     *
+     * No new card while one is open or the harness is accepting; none after
+     * Don't agree / a failed attempt unless the owner asked
+     * (`ownerInitiated`).
+     *
+     * @param runtime - Runtime id
+     * @param report - Source
+     * @returns The record, or null for a runtime without a profile
+     */
+    reportTermsScreen(runtime, report) {
+        if (!this.supports(runtime))
+            return Promise.resolve(null);
+        const prev = this.asking.get(runtime) ?? Promise.resolve(null);
+        const next = prev.catch(() => null).then(() => this.askOnce(runtime, report));
+        this.asking.set(runtime, next);
+        return next;
+    }
+    /**
+     * Settings → Runtimes → Accept terms…: post the card (or return the open one).
+     *
+     * @param runtime - Runtime id
+     * @returns The record
+     * @throws Error for a runtime without Terms handling
+     */
+    async requestConsent(runtime) {
+        if (!this.supports(runtime))
+            throw new Error(`Crewly has no Terms flow for ${runtime}`);
+        return (await this.reportTermsScreen(runtime, { source: 'settings', ownerInitiated: true }));
+    }
+    /**
+     * Probe: launch the runtime in the dedicated session, read (never press
+     * anything) until the screen is recognisable, close it. A Terms screen
+     * asks the owner (the owner asked for the check); a ready prompt means
+     * the Terms were accepted here already (e.g. in a terminal).
+     *
+     * @param runtime - Runtime id
+     * @returns What was on screen and the record after
+     * @throws Error while an answer is being applied, or for a runtime without a profile
+     */
+    async probe(runtime) {
+        const profile = this.deps.profiles[runtime];
+        if (!profile)
+            throw new Error(`Crewly has no Terms flow for ${runtime}`);
+        if (this.running.has(runtime) || this.deps.store.get(runtime)?.status === 'accepting') {
+            throw new Error('Crewly is already accepting these Terms; wait for it to finish');
+        }
+        const sleep = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        const timeout = this.deps.probeTimeoutMs ?? C.DRIVE.LAUNCH_TIMEOUT_MS;
+        let screen = '';
+        let outcome = 'unknown';
+        const session = await this.deps.launch(runtime);
+        try {
+            for (let waited = 0; waited <= timeout; waited += C.DRIVE.POLL_MS) {
+                screen = String(await session.terminal.capture());
+                outcome = profile.classify(screen);
+                if (outcome !== 'unknown')
+                    break;
+                await sleep(C.DRIVE.POLL_MS);
+            }
+        }
+        finally {
+            await session.close().catch(() => undefined);
+        }
+        if (outcome === 'terms') {
+            const record = await this.reportTermsScreen(runtime, { source: 'probe', ownerInitiated: true });
+            return { outcome, record, screen: redactSecrets(screen) };
+        }
+        if (outcome === 'ready') {
+            const prev = this.deps.store.get(runtime);
+            const record = this.save({ runtime, status: 'accepted', detectedBy: 'probe', ...(prev?.dataSharing !== undefined ? { dataSharing: prev.dataSharing } : {}) });
+            return { outcome, record, screen: redactSecrets(screen) };
+        }
+        return { outcome, record: this.deps.store.get(runtime), screen: redactSecrets(screen) };
+    }
+    /**
+     * Answer inline from Settings: through the open card when there is one
+     * (so the card updates), else directly.
+     *
+     * @param runtime - Runtime id
+     * @param choice - Owner's choice
+     * @returns The record after the answer was taken (driving continues in the background)
+     */
+    async answer(runtime, choice) {
+        if (!this.supports(runtime))
+            throw new Error(`Crewly has no Terms flow for ${runtime}`);
+        const rec = this.deps.store.get(runtime);
+        if (rec?.status === 'accepting')
+            throw new Error('Crewly is already accepting these Terms; wait for it to finish');
+        const decisions = this.deps.decisions();
+        if (rec?.decisionId && decisions) {
+            const d = await decisions.get(rec.decisionId);
+            const opt = d?.options.find((o) => o.label === TERMS_CHOICE_LABELS[choice]);
+            if (d && opt && PENDING_DECISION_STATUSES.has(d.status)) {
+                await decisions.chooseFromDashboard(d.id, opt.key);
+                return this.deps.store.get(runtime) ?? rec;
+            }
+        }
+        this.start(runtime, choice, undefined, 'owner');
+        return this.deps.store.get(runtime) ?? rec;
+    }
+    /**
+     * The `runtime_terms` decision-kind handler
+     * (`DecisionService.registerKindHandler`): acts on the answer. No agent
+     * asked, so there is no note for one.
+     *
+     * @param d - Settled decision
+     * @returns null (nothing to deliver)
+     */
+    async onSettled(d) {
+        this.handleSettled(d);
+        return null;
+    }
+    /**
+     * A decision was settled: act on runtime-terms ones.
+     *
+     * @param d - Settled decision
+     */
+    handleSettled(d) {
+        if (d.kind !== 'runtime_terms' || !d.system)
+            return;
+        const runtime = d.system.key;
+        const rec = this.deps.store.get(runtime);
+        if (!rec || rec.decisionId !== d.id) {
+            this.logger.info('Ignoring an old Terms decision', { decisionId: d.id, runtime });
+            return;
+        }
+        if (d.status === 'resolved') {
+            const choice = choiceOfLabel(d.options.find((o) => o.key === d.chosenKey)?.label);
+            if (choice)
+                this.start(runtime, choice, d.id, 'owner');
+            return;
+        }
+        if (d.status === 'defaulted') {
+            this.start(runtime, 'decline', d.id, 'deadline');
+            return;
+        }
+        // Withdrawn / parked: nothing was agreed.
+        this.start(runtime, 'decline', d.id, 'withdrawn');
+    }
+    /**
+     * Why a runtime cannot be used because of its Terms (null = it can).
+     *
+     * @param runtime - Runtime id
+     * @returns Owner-facing reason, or null
+     */
+    blockedReason(runtime) {
+        const rec = this.deps.store.get(runtime);
+        if (!rec)
+            return null;
+        switch (rec.status) {
+            case 'pending':
+                return C.MESSAGES.PENDING;
+            case 'accepting':
+                return 'Accepting its Terms of Service…';
+            case 'declined':
+                return `${C.MESSAGES.DECLINED_SUFFIX}: ${rec.reason ?? C.MESSAGES.DECLINED_BY_OWNER}`;
+            case 'failed':
+                return `${C.MESSAGES.DECLINED_SUFFIX}: the setup stopped (${rec.reason ?? 'unknown reason'})`;
+            default:
+                return null;
+        }
+    }
+    /** @returns Every runtime with a Terms flow, with its record */
+    list() {
+        const all = this.deps.store.all();
+        return Object.values(this.deps.profiles).map((p) => ({
+            ...(all[p.runtime] ?? { runtime: p.runtime, status: 'none' }),
+            label: p.label,
+            info: p.info,
+            blockedReason: this.blockedReason(p.runtime),
+            choices: Object.keys(TERMS_CHOICE_LABELS).map((choice) => ({ choice, label: TERMS_CHOICE_LABELS[choice] })),
+        }));
+    }
+    /**
+     * Wait for a running accept / decline (tests, the API's `?wait=1`).
+     *
+     * @param runtime - Runtime id
+     */
+    async whenIdle(runtime) {
+        await (this.asking.get(runtime) ?? Promise.resolve()).catch(() => undefined);
+        await (this.running.get(runtime) ?? Promise.resolve());
+    }
+    // ------------------------------------------------------------------ internals
+    async askOnce(runtime, report) {
+        const profile = this.deps.profiles[runtime];
+        const rec = this.deps.store.get(runtime);
+        if (rec?.status === 'accepting')
+            return rec;
+        const decisions = this.deps.decisions();
+        if (rec?.status === 'pending' && rec.decisionId && decisions) {
+            const open = await decisions.get(rec.decisionId).catch(() => null);
+            if (open && PENDING_DECISION_STATUSES.has(open.status))
+                return rec;
+        }
+        if ((rec?.status === 'declined' || rec?.status === 'failed') && !report.ownerInitiated)
+            return rec;
+        const machine = this.deps.machineName();
+        let decisionId;
+        if (decisions) {
+            const text = profile.card(machine);
+            try {
+                const d = await decisions.askSystem({
+                    kind: 'runtime_terms',
+                    system: { key: runtime, defaultIsDecline: true },
+                    title: text.title,
+                    question: text.question,
+                    body: text.body,
+                    options: [C.OPTIONS.AGREE_NO_DATA, C.OPTIONS.AGREE_SHARE_DATA, C.OPTIONS.DECLINE],
+                    default: C.OPTIONS.DECLINE,
+                    deadline: new Date(this.now().getTime() + C.DEADLINE_MS),
+                    sensitive: 'runtime_terms',
+                });
+                decisionId = d.id;
+            }
+            catch (err) {
+                this.logger.warn('Could not create the Terms decision card', { runtime, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+        const saved = this.save({
+            runtime,
+            status: 'pending',
+            ...(decisionId ? { decisionId } : {}),
+            detectedBy: report.source,
+        });
+        this.logger.info('Runtime Terms consent asked', { runtime, source: report.source, decisionId });
+        return saved;
+    }
+    start(runtime, choice, decisionId, why) {
+        if (this.running.has(runtime)) {
+            this.logger.warn('A Terms answer is already being applied; ignoring another', { runtime, choice });
+            return;
+        }
+        const run = (choice === 'decline' ? this.decline(runtime, decisionId, why) : this.accept(runtime, choice === 'agree_share_data', decisionId))
+            .catch((err) => this.logger.error('Applying the Terms answer failed', { runtime, error: err instanceof Error ? err.message : String(err) }))
+            .finally(() => this.running.delete(runtime));
+        this.running.set(runtime, run);
+    }
+    async decline(runtime, decisionId, why) {
+        const profile = this.deps.profiles[runtime];
+        await this.deps.closeSession?.(runtime).catch(() => undefined);
+        const reason = why === 'deadline' ? C.MESSAGES.DECLINED_BY_DEADLINE : why === 'withdrawn' ? 'The question was withdrawn without an answer' : C.MESSAGES.DECLINED_BY_OWNER;
+        this.save({ runtime, status: 'declined', reason, ...(decisionId ? { decisionId } : {}) });
+        const machine = this.deps.machineName();
+        const lead = why === 'deadline' ? 'No answer within 24 h, so nothing was accepted (the default).' : 'OK, not accepted.';
+        await this.reply(decisionId, `${lead} ${profile.label} is marked "terms not accepted" on ${machine}, and the fallback order skips it. ` +
+            `To change your mind: Settings → Runtimes → ${profile.label} → Accept terms…, or press Test.`);
+    }
+    async accept(runtime, shareData, decisionId) {
+        const profile = this.deps.profiles[runtime];
+        const machine = this.deps.machineName();
+        this.save({ runtime, status: 'accepting', ...(decisionId ? { decisionId } : {}), dataSharing: shareData });
+        let drive;
+        let session = null;
+        try {
+            session = await this.deps.launch(runtime);
+            drive = await profile.drive(session.terminal, shareData);
+        }
+        catch (err) {
+            drive = { ok: false, donePressed: false, alreadyAccepted: false, error: `Could not start ${profile.label}: ${err instanceof Error ? err.message : String(err)}`, keys: [], screen: '' };
+        }
+        finally {
+            await session?.close().catch(() => undefined);
+        }
+        this.logger.info('Runtime Terms screens driven', { runtime, ok: drive.ok, donePressed: drive.donePressed, alreadyAccepted: drive.alreadyAccepted, keys: drive.keys.length });
+        if (!drive.ok) {
+            this.save({
+                runtime,
+                status: 'failed',
+                reason: drive.error ?? 'unknown',
+                ...(decisionId ? { decisionId } : {}),
+                ...(drive.donePressed ? { dataSharing: drive.dataSharing } : {}),
+            });
+            const head = drive.donePressed
+                ? `:warning: Done was pressed on ${machine} (Terms accepted, data sharing ${drive.dataSharing ? 'on' : 'off'}), but then: ${drive.error}.`
+                : `:warning: Stopped on ${machine}; nothing was accepted (Done was not pressed): ${drive.error}.`;
+            await this.reply(decisionId, `${head}\nScreen:\n${screenForThread(drive.screen)}\nTo try again: Settings → Runtimes → ${profile.label} → Accept terms….`);
+            return;
+        }
+        this.save({
+            runtime,
+            status: 'accepted',
+            ...(decisionId ? { decisionId } : {}),
+            ...(drive.alreadyAccepted ? {} : { dataSharing: drive.dataSharing ?? shareData }),
+        });
+        await this.reply(decisionId, drive.alreadyAccepted
+            ? `${profile.label} on ${machine} was already set up (it opened straight to its prompt), so nothing was pressed. Running the runtime test…`
+            : `:white_check_mark: Accepted on ${machine}: ${profile.label}'s Terms, data sharing ${drive.dataSharing ? 'on' : 'off'} (checked on screen before Done). It opened to its prompt. Running the runtime test…`);
+        let smoke;
+        try {
+            smoke = await this.deps.runSmokeTest(runtime);
+        }
+        catch (err) {
+            await this.reply(decisionId, `Runtime test could not start: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        await this.reply(decisionId, smoke.passed
+            ? `Runtime test passed in ${Math.round(smoke.durationMs / 1000)}s: ${profile.label} ran bash and replied.`
+            : `Runtime test failed at "${(smoke.failedStep ?? 'unknown').replace(/_/g, ' ')}": ${smoke.error ?? 'no reason given'}` +
+                (smoke.screen ? `\nScreen:\n${screenForThread(smoke.screen)}` : ''));
+    }
+    async reply(decisionId, text) {
+        if (!decisionId)
+            return;
+        const decisions = this.deps.decisions();
+        if (!decisions)
+            return;
+        await decisions.replyInThread(decisionId, text).catch((err) => this.logger.warn('Could not reply in the Terms card thread', { decisionId, error: String(err) }));
+    }
+    save(fields) {
+        const saved = this.deps.store.set({ ...fields, updatedAt: this.now().toISOString() });
+        try {
+            this.deps.onChange?.(fields.runtime);
+        }
+        catch {
+            // cache invalidation only
+        }
+        return saved;
+    }
+}
+// ----------------------------------------------------------------- singleton
+let instance = null;
+/** @returns The backend's instance, or null before wiring (and in tests) */
+export function getRuntimeTermsConsentService() {
+    return instance;
+}
+/** @param service - Instance to install (null clears) */
+export function setRuntimeTermsConsentService(service) {
+    instance = service;
+}
+/**
+ * Report a Terms screen to the backend's service, when wired (fire and forget).
+ *
+ * @param runtime - Runtime id
+ * @param report - Source
+ */
+export function reportRuntimeTermsScreen(runtime, report) {
+    const svc = instance;
+    if (!svc)
+        return;
+    void svc.reportTermsScreen(runtime, report).catch(() => undefined);
+}
+//# sourceMappingURL=runtime-terms-consent.service.js.map