carthagent 1.1.0-beta.1 → 1.1.0-beta.3

package/docs/beta2-published-acceptance.md

@@ -0,0 +1,79 @@
+# Beta.2 release acceptance
+
+November 2, 2026. Immutable tag `v1.1.0-beta.2` points to
+`e14aeb17c213a927a27e9522da65db5928219647`.
+
+## Completed
+
+- Native onboarding PR #238 and first-task guidance PR #239 merged. Release PR
+  #240 merged with tag ancestry preserved at `fc5382364f41b1563ed137ed0db0c5711e041a83`.
+- Five-platform prebuild [41505735348](https://github.com/B-icy/Carthagent/actions/runs/41505735348)
+  passed. Local manifest regeneration verified all archive/executable hashes and
+  embedded provenance against the pinned runtime recipe.
+- Release CI [41509102387](https://github.com/B-icy/Carthagent/actions/runs/41509102387)
+  passed across Linux, macOS and Windows, including installed-package acceptance.
+- Final draft acceptance [41511681097](https://github.com/B-icy/Carthagent/actions/runs/41511681097)
+  passed against the exact tag, assets and main ancestry.
+- GitHub prerelease is public with five runtime archives, the manifest and
+  combined checksums. Independent anonymous verification of all five public
+  archives passed.
+- Release workflow [41512736590](https://github.com/B-icy/Carthagent/actions/runs/41512736590)
+  passed anonymous installed-package acceptance and reports successful npm
+  publication with signed provenance (transparency log index 3648230788).
+- Backend onboarding #178 and retention reporting #179 are deployed. Live
+  authenticated account identity and read-only plan terms were verified earlier.
+
+## npm publication verified
+
+After the workflow reported `+ carthagent@1.1.0-beta.2`, public registry requests
+from the acceptance environment still returned 404 for that exact version.
+Both npm CLI and cache-bypassed package metadata initially reported
+`next=1.1.0-beta.1`, `latest=1.0.7`. Registry visibility subsequently converged;
+no repeat publication was attempted.
+
+The public beta.2 tarball's SHA-512 matches registry integrity and the provenance
+subject digest. Sigstore verification passed for the GitHub Actions issuer and
+the repository's `release.yml@refs/heads/main` identity. The statement identifies
+release workflow 41512736590, and package `gitHead` matches the immutable tag.
+Verified tags: `next=1.1.0-beta.2`, `latest=1.0.7`.
+Evidence: `/tmp/opencode/beta2-npm-acceptance.json`.
+
+## Installed update verified
+
+The website command `npm install -g carthagent@next` installed beta.2 into an
+isolated Linux x64 home/prefix. Default runtime acquisition resolved the pinned
+CTG-owned executable with SHA-256
+`8a34735274c0b62049f6ae882dc955016fde54458efc18822fbcedb2e8eddeda`.
+The beta update check reported the installed version as current.
+Evidence: `/tmp/opencode/beta2-clean-install-acceptance.json`.
+
+An isolated npm installation of beta.1 detected beta.2 with
+`ctg update --channel beta --check`. Running `ctg update --channel beta` upgraded
+it to beta.2; a profile sentinel remained byte-for-byte intact. This used a
+disposable home and global npm prefix, not the user's normal installation.
+Evidence: `/tmp/opencode/beta2-update-acceptance.json`.
+
+## Remaining acceptance
+
+Stripe sandbox access subsequently became available. Real purchases, upgrades,
+SCA, renewal, failed renewal and cancellation were exercised separately against
+the isolated backend (see backend `docs/stripe-sandbox-acceptance.md`).
+
+An isolated published beta.2 login connected the authorized existing Cloud account.
+A real range-fix task passed four independent tests. Continuing that same session
+hit its persistent elapsed-time budget; beta.2 showed only an unexplained interrupt.
+The follow-up source fix adds actionable budget diagnostics and explicit
+`--reset-budget` support. With that source launcher and the same installed runtime,
+profile and session, continuation added an ascending-across-zero regression and
+passed all five independent tests. This launcher fix is not part of immutable beta.2.
+Execution budgets are not billing credit and never reset on payment or ordinary
+continuation. Evidence: `/tmp/opencode/stripe-acceptance/live-continuation-fixed.log`.
+
+Full task continuation across a genuine payment boundary remains incomplete:
+the real model task used existing Cloud credit and sandbox payments used a separate
+backend without a model upstream. Screenshot approval is not claimed. Local terminal timing failures
+were followed by passing full local, CI and draft acceptance; this does not prove
+that every terminal timing issue is resolved.
+
+The normal installed profile and Invest-With-Friends files were not changed by
+these release checks. Stable npm `latest` remains 1.0.7.

package/docs/cloud-onboarding-acceptance.md

@@ -0,0 +1,68 @@
+# Cloud onboarding — beta.2 implementation
+
+November 2, 2026. Beta.2 is published on GitHub and npm `next`; `latest` remains
+1.0.7. See [published acceptance](beta2-published-acceptance.md) for final CI,
+draft/public runtime gates, signed npm provenance, Linux clean installation and
+isolated beta.1 → beta.2 update evidence. Historical preparation notes below do
+not supersede that release record.
+
+Native PR #238 merged at `a5ad2164d056fee7f7183579ce6cc97305bae53b` after CI
+41504674623 passed. First-task guidance is tracked in PR #239. Beta.2 runtime
+prebuild 41505735348 succeeded. All five downloaded archives, executable digests
+and pinned provenance were independently verified by regenerating the candidate
+manifest locally. Package and lockfile target beta.2 and pin that exact manifest;
+publication remains pending.
+
+## Changes
+
+- Use Carthagent Cloud for hosted models; retain Ship mode, internal IDs and
+  compatibility login aliases.
+- Fresh device sign-in has one primary flow. Legacy import and upstream key
+  configuration require `CARTHAGENT_ADVANCED_AUTH=1`.
+- Billing selects Builder/Pro/Max and retrieves authenticated server quote terms.
+  TUI review precedes opening checkout. Existing subscribers review exact Stripe
+  proration in the browser before confirming a change.
+- `/billing refresh` and `ctg billing refresh` show current account access and
+  require explicit continuation in the existing task session.
+- Cloud account text identifies the signed-in email; usage recovery distinguishes
+  starter credit, daily/monthly limits, billing and own-provider access.
+
+## Verification
+
+- Full native suite: 1,131 passed, 5 skipped, 0 failed.
+  `/tmp/opencode/onboarding-native-reviewed.log`
+- Native build and typecheck pass.
+  `/tmp/opencode/onboarding-native-reviewed-build.log`
+- RPC regression verifies that eligibility comes from the authenticated server
+  and quoting does not create a checkout.
+- Native host acceptance passes at `b715ff282b` after correcting stale fresh-auth
+  and Cloud-name expectations. Both CI installed-package jobs passed. Run
+  41502591162 passed Linux/macOS and Windows 24; Windows 22 hit the two-second
+  PowerShell diagnostics timeout, while its parallel run passed. Windows
+  diagnostics now allow bounded ten-second cold startup.
+- Installed package acceptance and its focused terminal rerun reproduced a
+  reconnect overlay. DEBUG-enabled source and installed probes passed; a normal
+  source run subsequently hit its existing terminal-snapshot deadline. This is
+  timing-sensitive local acceptance, not proof of a fixed runtime defect. Both
+  earlier CI package checks passed, and corrected CI passed before merge.
+- The subsequent full non-focused installed-package run passed all 28
+  probes/scenarios, including terminal semantics, using the package-pinned
+  beta.1 owned runtime (`/tmp/opencode/onboarding-native-package-final.log`).
+  This closes the local rerun gate for the onboarding source; beta.2 still
+  requires acceptance against its own final packaged manifest and release assets.
+
+## Outstanding gates
+
+Backend counterpart: `B-icy/Carthagent-Backend` PR #178 merged at
+`b0eacdcbdb71be4c099b1b3839a11164b2d69232`; production deployment 41502378359
+succeeded. Its `ONBOARDING_CONVERSION_AUDIT.md` tracks the full matrix. Live
+authenticated identity and read-only Builder/Pro/Max handoff terms were verified.
+Retention follow-up PR #179 also merged and deployment 41505976672 succeeded.
+Stripe test access is unavailable. First-task/default-model guidance,
+contextual exhaustion action, remaining legacy/docs naming and full measurement
+segmentation still need work. No new end-to-end paid continuation or visual
+screenshot acceptance is claimed.
+
+The deployed website now precedes the native release. Publish a new immutable
+beta and verify its exact public acquisition and upgrade. Preserve the user's
+normal profile and Invest-With-Friends work during acceptance.

package/docs/release-notes-beta.2.md

@@ -0,0 +1,60 @@
+# Carthagent 1.1.0-beta.2 — release candidate
+
+This candidate simplifies Cloud sign-in and keeps billing recovery connected to
+the task already open in your terminal. Publication and installed acceptance are
+pending; these notes do not establish availability on npm.
+
+## Cloud sign-in and first use
+
+- Hosted models are named **Carthagent Cloud**. **Ship mode** remains the verified
+  coding workflow. Existing provider IDs and login aliases continue to work.
+- Fresh Cloud sign-in goes directly through browser authorization. Legacy import
+  and upstream-key methods require `CARTHAGENT_ADVANCED_AUTH=1`.
+- The browser identifies the account and terminal being connected. Device codes
+  last 20 minutes, with continuation-preserving sign-in recovery.
+- Successful CLI sign-in suggests one small project task and points Cloud users
+  to `/account` for identity and actual available usage.
+
+## Review billing, then continue explicitly
+
+- `/billing checkout builder`, `pro` or `max` shows authenticated plan terms
+  before opening checkout. Eligible new Builder customers pay **$1 for the first
+  month, then $10/month**; Pro starts at **$25/month**, Max at **$50/month**.
+- The separate one-time starter usage credit is attempted on first terminal
+  authorization. Browser signup alone does not grant it.
+- Existing card subscribers review Stripe's prorated amount before confirming a
+  change. The renewal anchor and consumed/reserved usage are preserved. Existing
+  grandfathered subscriptions retain their documented allowance policy.
+- After payment, run `/billing refresh` in the existing session, or
+  `ctg billing refresh` outside the TUI. Then explicitly continue the task.
+  Checkout does not automatically submit a prompt or restart work.
+
+## Acceptance and limitations
+
+Backend onboarding and retention reporting are deployed through PRs #178 and
+#179. Native onboarding PR #238 is merged; first-task guidance is in PR #239.
+The original onboarding suite passed 1,131 tests with five skips; corrected
+native CI passed on Linux, macOS and Windows. These results precede final
+beta.2 installed-package and public-acquisition acceptance.
+
+Stripe test-mode access remains unavailable; real decline/SCA, tax/discount and
+the full financial-transition matrix are not verified. No new live purchase or
+end-to-end paid task continuation is claimed. Browser screenshot capture remains
+unavailable. Local terminal acceptance initially showed event-stream timing
+failures; the subsequent full installed-package run passed all 28 probes/scenarios
+with the pinned beta.1 runtime, as did CI package acceptance. Final beta.2 draft
+acceptance against its own manifest and assets is still required.
+
+Verified-delivery rewards remain 25 coins, 100 XP and 1 km per eligible claimed
+delivery, up to three per UTC day. Daily classifier assessments remain unrewarded.
+
+## Planned release channel
+
+The candidate targets npm `next` and the beta updater channel. Stable `latest`
+remains 1.0.7. Exact installation and update instructions will be verified after
+the immutable release and its five runtime archives are published.
+
+Runtime prebuild: [41505735348](https://github.com/B-icy/Carthagent/actions/runs/41505735348),
+source `d999644028ed0c0dc70bcaf58060db4018278e48`. The runtime recipe remains
+combined-v5 on upstream `843a6c514e606b436a7fe713422ace0a93ad3d61`, compatibility
+2.0.32. The final package must pin the generated archive and executable digests.

package/docs/release-notes-beta.3.md

@@ -0,0 +1,47 @@
+# Carthagent 1.1.0-beta.3 — release candidate
+
+This candidate makes continuation failures actionable. Publication is pending;
+these notes do not establish npm availability.
+
+## Continue the existing task
+
+- An exhausted persistent execution budget now reports the reason and recovery
+  command instead of an unexplained interrupt.
+- `--reset-budget` explicitly authorizes a fresh budget for a resumed session:
+
+  ```sh
+  ctg --print --continue --reset-budget "Continue the task"
+  ```
+
+- Ordinary continuation and payment preserve the execution budget, including
+  elapsed idle time. Billing credit is separate. Interactive users can run
+  `/delivery-budget-reset` before continuing the existing task.
+- CLI help consistently names Carthagent Cloud and documents `billing refresh`.
+
+## Acceptance evidence
+
+The source fix passed 1,132 tests with five skips, builds and lint. PR #242 CI
+passed Linux, macOS and Windows, browser and installed-package gates. One macOS
+22 service-stop identity timeout passed on retry; the separate push run passed.
+
+The authorized existing Cloud account completed a real range-fix task. The same
+session, profile and installed beta.2 runtime then continued with the source
+launcher and explicit reset, adding a regression and passing all five project
+tests independently. Final beta.3 installed acceptance remains required.
+
+Backend PRs #180–181 are deployed: automatic payment-status checks, clearer
+sign-in and refund guidance, direct Builder review, modern Stripe compatibility
+and accurate scheduled-cancellation dates while retaining paid access.
+Sandbox purchases, prorated upgrades, initial and upgrade SCA, declined-upgrade
+recovery, renewal, failed renewal, automatic refunds and disputes were exercised
+separately. These do not establish a single
+useful-task → payment boundary → same-task continuation journey: the model task
+used existing production credit and payments used an isolated sandbox backend.
+
+## Release channel
+
+Targets npm `next`; stable `latest` remains 1.0.7. Runtime prebuild
+[41537249365](https://github.com/B-icy/Carthagent/actions/runs/41537249365) uses
+reviewed source `c11103f8b57c6b3254473a78d535a404bea9a84a` and the unchanged
+combined-v5 runtime recipe. Final assets and manifest must pass immutable draft
+acceptance before publication.

package/lib/cloud/client.mjs

@@ -73,7 +73,7 @@ export class CloudClient {
   }
 
   async request(path, { method = 'GET', accessToken, body, signal } = {}) {
-    if (typeof this.fetch !== 'function') throw new Error('Carthagent Ship requires fetch support.');
+    if (typeof this.fetch !== 'function') throw new Error('Carthagent Cloud requires fetch support.');
     const headers = { accept: 'application/json' };
     if (body !== undefined) headers['content-type'] = 'application/json';
     if (accessToken) headers.authorization = `Bearer ${accessToken}`;
@@ -128,6 +128,11 @@ export class CloudClient {
     return this.request('/v1/billing/checkout', { method: 'POST', accessToken, body: { successUrl, cancelUrl, priceId }, signal });
   }
 
+  /** @param {{ accessToken?: string, plan?: string, signal?: AbortSignal }} [input] */
+  quote({ accessToken, plan = 'builder', signal } = {}) {
+    return this.request(`/v1/billing/quote?plan=${encodeURIComponent(plan)}`, { accessToken, signal });
+  }
+
   portal({ accessToken, returnUrl, signal } = {}) {
     return this.request('/v1/billing/portal', { method: 'POST', accessToken, body: { returnUrl }, signal });
   }
@@ -184,10 +189,10 @@ function formatEpochSeconds(value) {
 
 export function cloudManagedUsageRecovery(value) {
   const text = String(value?.code || value?.message || value || '');
-  if (/daily_limit_reached|managed daily usage limit/i.test(text)) return 'Managed daily usage is exhausted. It resets at 00:00 UTC. Use /account for headroom or /login for BYOK.';
-  if (/monthly_allowance_exhausted|managed monthly allowance/i.test(text)) return 'Managed monthly usage is exhausted. Use /billing portal to manage the plan or /login for BYOK.';
-  if (/subscription_inactive|managed subscription is not active/i.test(text)) return 'The managed subscription is inactive. Use /billing portal or /login for BYOK.';
-  if (/insufficient_quota|insufficient.credit|credit (?:is )?exhausted/i.test(text)) return 'Carthagent Ship credit is exhausted. Use /billing checkout where available or /login for BYOK.';
+  if (/daily_limit_reached|managed daily usage limit/i.test(text)) return 'Cloud daily usage is exhausted. It resets at 00:00 UTC. Use /account for your plan and headroom, /billing portal to manage billing, or /login for your own provider (BYOK). Your task stays in this session.';
+  if (/monthly_allowance_exhausted|managed monthly allowance/i.test(text)) return 'Cloud monthly usage is exhausted. Use /account for your renewal date, /billing portal to manage billing, or /login for your own provider (BYOK). To review a different plan use /billing checkout pro or /billing checkout max. After payment use /billing refresh, then explicitly continue this task.';
+  if (/subscription_inactive|managed subscription is not active/i.test(text)) return 'Cloud access is awaiting payment or activation. Use /billing refresh to check, /billing portal to manage payment, or /login for your own provider.';
+  if (/insufficient_quota|insufficient.credit|credit (?:is )?exhausted/i.test(text)) return 'Carthagent Cloud usage credit is exhausted. Use /billing checkout builder to review your eligible price (new Builder customers: $1 first month, then $10/month), or /login for your own provider. After payment use /billing refresh, then explicitly continue this task.';
   return null;
 }
 
@@ -256,9 +261,10 @@ export function formatCloudAccount(account, { usage } = {}) {
   const managed = account?.managedUsage;
   const planName = managed?.planName || 'plan';
   const lines = [
-    `Carthagent Ship account ${account?.accountId || 'unknown'}`,
+    `Carthagent Cloud account ${account?.accountId || 'unknown'}`,
     `Credit: ${formatNanoUsd(account?.balance?.availableNanoUsd)} available`,
-    `Plan: ${subscription.status && subscription.status !== 'none' ? `${planName} (${subscription.status})` : 'Free'}`,
+    `Plan: ${subscription.status && subscription.status !== 'none' ? `${planName} (${subscription.status})` : 'No paid plan'}`,
+    ...(account?.email ? [`Signed in as: ${account.email}`] : []),
   ];
   const subscriptionEnd = formatEpochSeconds(subscription.current_period_end);
   if (subscriptionEnd) lines.push(`Renews/ends: ${subscriptionEnd}`);

package/lib/opencode/cli-runtime.mjs

@@ -100,8 +100,9 @@ function errorText(error) {
 function headlessFailureMessage(latest, headlessError) {
   const raw = errorText(latest?.error ?? latest?.session?.error ?? lastAssistantError(latest?.messages) ?? headlessError);
   const outcome = latest?.outcome ?? latest?.session?.outcome;
+  if (['elapsed-time', 'tool-calls', 'repair-rounds'].includes(latest?.budgetReason)) return `Session execution budget exhausted: ${latest.budgetReason}. Billing refresh does not reset execution limits. To authorize a fresh budget, resume this session with --reset-budget (for example: ctg --print --continue --reset-budget "Continue the task"), or run /delivery-budget-reset in the existing terminal session before continuing.`;
   if (/ModelNotSelectedError|No model is available|no provider|provider.*not (connected|selected|configured)|not authenticated/i.test(raw ?? '')) {
-    return 'No AI provider connected. Run `ctg login` to connect one (Carthagent Ship is recommended), or set an API key env var (e.g. ANTHROPIC_API_KEY), then retry. Run `ctg native --list-models` to see available models.';
+    return 'No AI provider connected. Run `ctg login` to connect one (Carthagent Cloud is recommended), or set an API key env var (e.g. ANTHROPIC_API_KEY), then retry. Run `ctg native --list-models` to see available models.';
   }
   if (raw) return `Native run failed: ${raw}`;
   if (latest?.reason || latest?.budgetReason) return `Native run failed: ${latest.reason ?? latest.budgetReason}`;
@@ -311,10 +312,10 @@ function shipLoginGuidance(error) {
   const message = String(error?.data?.message || error?.message || '');
   const type = String(error?.type || error?.data?.type || '');
   if (type === 'ship.unauthenticated' || type === 'ship.not-connected') {
-    return 'Carthagent Ship is not connected. Run `ctg login` and choose Carthagent Ship, then retry.';
+    return 'Carthagent Cloud is not connected. Run `ctg login` and choose Carthagent Cloud, then retry.';
   }
-  if (/active Carthagent Ship OAuth connection is required|not authenticated|unauthorized/i.test(message)) {
-    return 'Carthagent Ship is not connected. Run `ctg login` and choose Carthagent Ship, then retry.';
+  if (/active Carthagent (?:Ship|Cloud) OAuth connection is required|not authenticated|unauthorized/i.test(message)) {
+    return 'Carthagent Cloud is not connected. Run `ctg login` and choose Carthagent Cloud, then retry.';
   }
 }
 
@@ -559,6 +560,9 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
           options.session = await latestSessionForWorkspace(client, cwd);
           if (!options.session) throw new Error('No native Carthagent session exists for this workspace to continue.');
         }
+        if (options.resetBudget && !options.session && !options.continue && !options.resume) {
+          throw new Error('--reset-budget requires --session, --continue or --resume.');
+        }
         eventController = new AbortController();
         const nativeEvents = [];
         let eventFailure;
@@ -600,6 +604,9 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
           const definitions = native.rpcDefinitions ?? await nativeRpcDefinitions();
           await client.rpc(definitions.SessionControls).framing({ sessionID, enabled: options.autoFraming }, { location: { directory: cwd }, signal: signal.controller.signal });
         }
+        if (options.resetBudget && sessionID) {
+          await client.session.command({ sessionID, name: 'delivery-budget-reset', text: '' }, { location: { directory: cwd }, signal: signal.controller.signal });
+        }
         if (framedPrompt) {
           if (!sessionID) {
             const created = await headlessApi.createSession(service, cwd, { body: {
@@ -644,6 +651,11 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
         const definitions = native.rpcDefinitions ?? await nativeRpcDefinitions();
         await client.rpc(definitions.SessionControls).framing({ sessionID: requestedSession, enabled: options.autoFraming }, { location: { directory: cwd }, signal: signal.controller.signal });
       }
+      if (requestedSession && options.resetBudget && !signal.controller.signal.aborted) {
+        const resumed = await client.session.get({ sessionID: requestedSession }, { signal: signal.controller.signal });
+        assertSessionWorkspace(resumed, cwd);
+        await client.session.command({ sessionID: requestedSession, name: 'delivery-budget-reset', text: '' }, { location: { directory: cwd }, signal: signal.controller.signal });
+      }
       try {
         result = await headlessApi.runHeadless(service, cwd, framedPrompt || prompt || '', {
           sessionID: options.session,
@@ -658,7 +670,16 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
         headlessError = error;
         result = { session: { id: options.session }, messages: [], outcome: signal.controller.signal.aborted ? 'interrupted' : 'failed', terminal: true, error: error.message };
       }
-        const latest = headlessError ? result : await reconcileHeadlessResult(result, { client, signal: signal.controller.signal });
+        let latest = headlessError ? result : await reconcileHeadlessResult(result, { client, signal: signal.controller.signal });
+        if (latest.outcome === 'interrupted' && !latest.error && !latest.session?.error && !lastAssistantError(latest.messages) && latest.session?.id && typeof client.rpc === 'function' && !signal.controller.signal.aborted) {
+          // An interrupt may carry no error in the host projection. Read the
+          // authoritative persistent budget without restarting the task.
+          try {
+            const definitions = native.rpcDefinitions ?? await nativeRpcDefinitions();
+            const budget = await client.rpc(definitions.Carthagent).budgetStatus({ sessionID: latest.session.id }, { location: { directory: cwd }, signal: AbortSignal.any([signal.controller.signal, AbortSignal.timeout(2000)]) });
+            if (budget?.stopped) latest = { ...latest, budgetReason: budget.stopped, error: latest.error ?? headlessFailureMessage({ budgetReason: budget.stopped }) };
+          } catch { /* Keep the original failure when budget status is unavailable. */ }
+        }
         eventController.abort();
         await eventReader;
         if (eventFailure) throw new Error(`Native Carthagent event stream failed: ${eventFailure.message}`, { cause: eventFailure });
@@ -720,7 +741,7 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     if (!rows.length) {
       io.error(term
         ? `No models match "${query.trim()}". Run \`ctg native --list-models\` to see every available model, or \`ctg login\` to connect a provider.`
-        : 'No AI provider connected, so no models are available. Run `ctg login` to connect one (Carthagent Ship is recommended), or set an API key env var (e.g. ANTHROPIC_API_KEY), then run `ctg native --list-models` again.');
+        : 'No AI provider connected, so no models are available. Run `ctg login` to connect one (Carthagent Cloud is recommended), or set an API key env var (e.g. ANTHROPIC_API_KEY), then run `ctg native --list-models` again.');
     }
     return rows.length;
   }
@@ -741,6 +762,12 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     let integration;
     let attempt;
     let completed = false;
+    const connected = () => {
+      completed = true;
+      io.log(`Connected to ${integration.name}.`);
+      io.log('Run ctg in your project. Start small: “Find one failing test, explain the cause, and fix it with a regression test.”');
+      if (integration.id === 'experiential-labs') io.log('Use /account to check the connected account and available usage. Starter usage is granted only when eligible.');
+    };
     try {
     ({ client } = await serviceClient());
     location = { directory: cwd };
@@ -809,7 +836,7 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     }
     if (method.type === 'external') {
       await client.integration.connect.external({ integrationID: integration.id, methodID: method.id, answer, location }, { signal: controller.signal });
-      io.log(`Connected to ${integration.name}.`);
+      connected();
       return 0;
     }
     if (method.type === 'key') {
@@ -817,8 +844,7 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
       const key = secretField ? answer[secretField.key] : await questionMasked(stdin, stdout, `${integration.name} API key`, controller.signal);
       if (typeof key !== 'string' || !key.trim()) throw new Error('An API key is required.');
       await client.integration.connect.key({ integrationID: integration.id, key, answer, location }, { signal: controller.signal });
-      io.log(`Connected to ${integration.name}.`);
-      completed = true;
+      connected();
       return 0;
     }
     if (method.type !== 'oauth') throw new Error(`Authentication method ${method.type} is not supported by native CLI login.`);
@@ -838,15 +864,14 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
         code = await questionWithAbort(prompt, 'Paste the authorization code: ', controller.signal);
         if (!code.trim()) throw new Error('Authorization code is required.');
         await client.integration.oauth.complete({ integrationID: integration.id, attemptID: attempt.attemptID, code: code.trim(), location }, { signal: controller.signal });
-        io.log(`Connected to ${integration.name}.`);
-        completed = true;
+        connected();
         return 0;
       }
       io.log('Waiting for authorization… (Ctrl+C to cancel)');
       while (!controller.signal.aborted && Date.now() < attempt.time.expires) {
         const response = await client.integration.oauth.status({ integrationID: integration.id, attemptID: attempt.attemptID, location }, { signal: controller.signal });
         const status = response.data;
-        if (status.status === 'complete') { io.log(`Connected to ${integration.name}.`); completed = true; return 0; }
+        if (status.status === 'complete') { connected(); return 0; }
         if (status.status === 'failed') throw new Error(status.message || 'Authorization failed.');
         if (status.status === 'expired') throw new Error('Authorization expired.');
         await new Promise((resolve, reject) => {
@@ -929,7 +954,7 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     const auth = await shipCredential();
     let result;
     try { result = (await auth.rpc.shipAccount({}, { location: { directory: cwd } })).account; }
-    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Ship: ${error.message}`); }
+    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Cloud: ${error.message}`); }
     const cloud = await cloudClient('');
     if (args.includes('--json')) io.log(JSON.stringify(result));
     else {
@@ -942,13 +967,26 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     return 0;
   }
 
-  async function billing({ action }) {
+  async function billing({ action, plan }) {
+    if (action === 'refresh') {
+      const result = await account();
+      io.log('Return to your existing session. When usage is available, explicitly continue the task.');
+      return result;
+    }
     const auth = await shipCredential();
     let result;
-    try { result = await auth.rpc.shipBilling({ action }, { location: { directory: cwd } }); }
-    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Ship: ${error.message}`); }
+    try {
+      if (action === 'checkout') {
+        const { quote } = await auth.rpc.shipBilling({ action: 'quote', ...(plan ? { plan } : {}) }, { location: { directory: cwd } });
+        io.log(quote.terms);
+        if (quote.changingPlan) io.log('Review the exact proration in your browser before confirming the change.');
+      }
+      result = await auth.rpc.shipBilling({ action, ...(plan ? { plan } : {}) }, { location: { directory: cwd } });
+    }
+    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Cloud: ${error.message}`); }
     const opened = await openBrowserImpl(result.url).catch(() => false);
     io.log(`${opened ? 'Opened' : 'Open'} ${result.url}`);
+    io.log('After payment, run ctg billing refresh. Return to your existing session and explicitly continue the task.');
     return 0;
   }
 
@@ -956,11 +994,11 @@ export async function createOpenCodeCliRuntime({ cwd = process.cwd(), io = conso
     const auth = await shipCredential();
     let result;
     try { result = await auth.rpc.shipLogout({ ...(sessionID ? { session: sessionID } : {}) }, { location: { directory: cwd } }); }
-    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Ship logout: ${error.message}`); }
+    catch (error) { throw new Error(shipLoginGuidance(error) || `Carthagent Cloud logout: ${error.message}`); }
     if (!sessionID && result.credentialID) {
       await auth.client.credential.remove({ credentialID: result.credentialID });
     }
-    io.log(sessionID ? `Revoked Ship session ${sessionID}.` : 'Revoked and removed the current Carthagent Ship session.');
+    io.log(sessionID ? `Revoked Cloud session ${sessionID}.` : 'Revoked and removed the current Carthagent Cloud session.');
     return 0;
   }
 

package/lib/opencode/cli.mjs

@@ -26,6 +26,7 @@ const BOOL_FLAGS = new Map([
   ['--protect-existing', ['protectExisting', true]], ['--jev', ['jev', true]], ['--no-jev', ['jev', false]],
   ['--print', ['print', true]], ['--demo', ['demo', true]], ['-c', ['continue', true]],
   ['--continue', ['continue', true]], ['-r', ['resume', true]], ['--resume', ['resume', true]],
+  ['--reset-budget', ['resetBudget', true]],
 ]);
 
 const aliases = new Map([
@@ -84,9 +85,9 @@ export function cliHelp(version = '') {
   \x1b[32mhash\x1b[0m, \x1b[32mfingerprint\x1b[0m     Calculate workspace SHA-256 fingerprint
   \x1b[32mvalidate\x1b[0m <file.json> Validate acceptance contract
   \x1b[32mlogin\x1b[0m, \x1b[32mauth\x1b[0m             Connect an AI provider
-  \x1b[32maccount\x1b[0m               Show Ship credit, plan, grants and CLI sessions
-  \x1b[32mbilling\x1b[0m [checkout|portal] Open Ship billing
-  \x1b[32mlogout-cloud\x1b[0m [session] Revoke the current or named Ship session
+  \x1b[32maccount\x1b[0m               Show Cloud credit, plan, grants and CLI sessions
+  \x1b[32mbilling\x1b[0m [checkout|portal|refresh] Open or refresh Cloud billing
+  \x1b[32mlogout-cloud\x1b[0m [session] Revoke the current or named Cloud session
   \x1b[32marchive\x1b[0m [list|search|read|export] Read-only legacy session archive
   \x1b[32mreview\x1b[0m                Configure self-review or review a PR
   \x1b[32mserve\x1b[0m, \x1b[32mweb\x1b[0m, \x1b[32mstart\x1b[0m     Start the web dashboard
@@ -110,6 +111,8 @@ export function cliHelp(version = '') {
   --max-tools <n>          Session tool-call budget (0 disables)
   --max-seconds <n>        Session elapsed-time budget (0 disables)
   --max-repairs <n>        Automatic-repair budget (0 disables)
+  --reset-budget           Explicitly reset a resumed session's execution budget
+                           Budgets persist across continuation, including idle time.
   --protect-existing      Preserve files present at session start
   --rewrite-cap <n>        Whole-file writes per path (0 disables)
   --tool-output-cap <n>    Bound text output per tool result
@@ -189,15 +192,16 @@ export async function runOpenCodeCli({ argv = [], runtime, io = console, stdoutI
       return fail(error.message, 1, io);
     }
   }
-  if (normalized === 'logout') return fail('Use `logout-cloud` to revoke a Carthagent Ship session; provider credentials are managed by the native runtime.', 1, io);
+  if (normalized === 'logout') return fail('Use `logout-cloud` to revoke a Carthagent Cloud session; provider credentials are managed by the native runtime.', 1, io);
   if (normalized === 'account' || normalized === 'cloud') {
     try { return Number((await ensureMethod(runtime, 'account')({ args: rest })) ?? 0); }
     catch (error) { return fail(error.message, 1, io); }
   }
   if (normalized === 'billing') {
     const action = rest[0] || 'checkout';
-    if (!['checkout', 'portal'].includes(action)) return fail('Usage: ctg billing [checkout|portal]', 1, io);
-    try { return Number((await ensureMethod(runtime, 'billing')({ action })) ?? 0); }
+    const plan = rest[1];
+    if (!['checkout', 'portal', 'refresh'].includes(action) || (plan && !['builder', 'pro', 'max'].includes(plan))) return fail('Usage: ctg billing [checkout [builder|pro|max]|portal|refresh]', 1, io);
+    try { return Number((await ensureMethod(runtime, 'billing')({ action, ...(plan ? { plan } : {}) })) ?? 0); }
     catch (error) { return fail(error.message, 1, io); }
   }
   if (normalized === 'logout-cloud') {

package/lib/opencode/provider-policy.mjs

@@ -1,5 +1,5 @@
 export const NATIVE_LOGIN_PROVIDERS = Object.freeze([
-  Object.freeze({ id: 'experiential-labs', name: 'Carthagent Ship', aliases: ['ship'], oauth: 'carthagent-device' }),
+  Object.freeze({ id: 'experiential-labs', name: 'Carthagent Cloud', aliases: ['cloud', 'ship', 'carthagent ship'], oauth: 'carthagent-device' }),
   Object.freeze({ id: 'anthropic', name: 'Claude / Anthropic', aliases: ['claude', 'claudecode'] }),
   Object.freeze({ id: 'xai', name: 'xAI / Grok', aliases: ['grok', 'xai-code'], oauth: 'device' }),
   Object.freeze({ id: 'openai', name: 'Codex / OpenAI', aliases: ['codex', 'openai-codex'], oauth: 'chatgpt-token-sharing' }),

package/lib/opencode/runtime-release.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "releaseVersion": "1.1.0-beta.1",
+  "releaseVersion": "1.1.0-beta.3",
   "compatibilityVersion": "2.0.32",
   "runtimeVersion": "0.0.0-ctg.2.0.32",
   "sourceRevision": "843a6c514e606b436a7fe713422ace0a93ad3d61",
@@ -9,28 +9,28 @@
   "assets": {
     "linux-x64": {
       "name": "opencode-linux-x64.tar.gz",
-      "archiveSha256": "e0abac9f7e9d99f1b3b88d11e1efb7ce1de08b7e7474de33c1279ec1797d1aae",
-      "executableSha256": "f6dd022de1854d67056b1e8b039196dcb69f887e5fe5dc8839e75d40debb9cc1"
+      "archiveSha256": "ab95bd99fc2bf52f867927a817dde1d3882122b80f85ef85cf416733afa62483",
+      "executableSha256": "f9ad13d8aad76bf1d16334712f0060b886757f5cdabddacce42f9805d4482c1c"
     },
     "linux-arm64": {
       "name": "opencode-linux-arm64.tar.gz",
-      "archiveSha256": "cf2e5b020b100801e817d650b8f57ba82118036ffb4f0296b29af4a9ce9c5afd",
-      "executableSha256": "e494c40d16934576338ea8ddd7ad5a4935fc0dc8e1efcebd78eb8074af2a795f"
+      "archiveSha256": "3869dd9398693afffe9f438192fbb12061b66a211993018379fb6870d2012bd2",
+      "executableSha256": "0c302d55bba608d83c42f54b769ec3994421d3dcb16ea5d2a9455dcd91f884a1"
     },
     "darwin-x64": {
       "name": "opencode-darwin-x64.tar.gz",
-      "archiveSha256": "ed5f5cfa0edeca391ecaf7789347916c3d1779b9b1c8afb6feafb6a1fa82e95c",
-      "executableSha256": "eddb5ac76384986a05cd86aecf4abe6fb76b11f0370775a515b46e07a6875e9c"
+      "archiveSha256": "b20111d8fd2368ac9bde7f90b12835a465b8c92da3db1f3a35671860a325eb27",
+      "executableSha256": "23f7a845e75592efa11dff407e147287584eae7f63fca1a9c4ccbe9558656bc3"
     },
     "darwin-arm64": {
       "name": "opencode-darwin-arm64.tar.gz",
-      "archiveSha256": "f3ee781431819b5d1a5c35905d88d56cef0ead5b96b7007da6e046e531a6a87d",
-      "executableSha256": "3afa14710324db7db3598d51c7616405615d78c3804fd77faf82b424747561fa"
+      "archiveSha256": "eb65c635c8cf19f0830b56b2d8087387148edaf44cf821c881b72388c9c185fd",
+      "executableSha256": "d10a7b549748a131c578ed8cd041aeb652f1ae9c79c5f3912a731f2a69218736"
     },
     "windows-x64": {
       "name": "opencode-windows-x64.tar.gz",
-      "archiveSha256": "8a433fa26fccc04e010009f9ffe368c322d867a3030cb3bb831bca3e23c328f1",
-      "executableSha256": "139325dd6b5d9535b0259dec236b6493671909c6f61ed9ae7772b80b41332037"
+      "archiveSha256": "a0309761781f57b5ea9f329d41f2e977391949addc9baaca6b85025780249d3c",
+      "executableSha256": "91eac290633313c7fce4a426ef265f193e995b285746df6a2a6010f4727fe813"
     }
   }
 }

package/lib/providers/names.mjs

@@ -1,5 +1,5 @@
 export const CARTHAGENT_SHIP_PROVIDER_ID = 'experiential-labs';
-export const CARTHAGENT_SHIP_PROVIDER_NAME = 'Carthagent Ship';
+export const CARTHAGENT_SHIP_PROVIDER_NAME = 'Carthagent Cloud';
 
 export function providerDisplayName(providerId) {
   return providerId === CARTHAGENT_SHIP_PROVIDER_ID ? CARTHAGENT_SHIP_PROVIDER_NAME : String(providerId || '');

package/lib/tui/models.mjs

@@ -30,7 +30,7 @@ export function providerForModel(model, list) {
 export function modelMatchesQuery(model, query) {
   const tokens = String(query || '').toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
   if (!tokens.length) return true;
-  const searchable = [model?.provider, providerDisplayName(model?.provider), model?.id, model?.full, model?.name]
+  const searchable = [model?.provider, providerDisplayName(model?.provider), model?.provider === 'experiential-labs' ? 'Carthagent Ship' : '', model?.id, model?.full, model?.name]
     .filter(Boolean)
     .join(' ')
     .toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carthagent",
-  "version": "1.1.0-beta.1",
+  "version": "1.1.0-beta.3",
   "workspaces": [
     "plugins/carthagent"
   ],

package/plugins/carthagent/src/rpc.ts

@@ -95,8 +95,8 @@ export const Carthagent = Rpc.define({
       output: { type: 'object', properties: { usage: { type: 'object', additionalProperties: true } }, required: ['usage'], additionalProperties: false },
     },
     shipBilling: {
-      input: { type: 'object', properties: { action: { type: 'string', enum: ['checkout', 'portal'] } }, required: ['action'], additionalProperties: false },
-      output: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'], additionalProperties: false },
+      input: { type: 'object', properties: { action: { type: 'string', enum: ['checkout', 'portal', 'quote'] }, plan: { type: 'string', enum: ['builder', 'pro', 'max'] } }, required: ['action'], additionalProperties: false },
+      output: { type: 'object', properties: { url: { type: 'string' }, quote: { type: 'object', additionalProperties: true } }, additionalProperties: false },
       errors: { unauthenticated: { type: 'object', properties: {}, additionalProperties: false } },
     },
     shipLogout: {

package/plugins/carthagent/src/server/providers.ts

@@ -120,19 +120,18 @@ function oauthMethod({ env, fetchImpl, sleep, now, openBrowserImpl, agentDir, st
   return {
     integrationID: IntegrationSchema.ID.make(SHIP_INTEGRATION_ID),
     method: {
-      id: OAUTH_METHOD, type: 'oauth' as const, label: 'Sign in with Carthagent Ship',
-      form: [{ type: 'boolean' as const, key: 'importLegacy', title: 'Import a legacy Ship credential instead of signing in?',
-        description: 'Leave disabled for fresh browser approval and updated account permissions.', default: false }] satisfies Form.Fields,
+      id: OAUTH_METHOD, type: 'oauth' as const, label: 'Continue with Carthagent Cloud',
+      ...(env.CARTHAGENT_ADVANCED_AUTH === '1' ? { form: [{ type: 'boolean' as const, key: 'importLegacy', title: 'Import a legacy Cloud credential?', default: false }] satisfies Form.Fields } : {}),
     },
     authorize: async (answer: Form.Answer) => {
       // The legacy file intentionally survives migration. Never let its presence
       // short-circuit an explicit sign-in or recovery from revoked/old scopes.
-      const legacy = answer.importLegacy === true ? await legacyOAuthForOpenCode({ agentDir }) : undefined;
+      const legacy = env.CARTHAGENT_ADVANCED_AUTH === '1' && answer.importLegacy === true ? await legacyOAuthForOpenCode({ agentDir }) : undefined;
       if (legacy) {
         return {
           mode: 'auto' as const,
           url: 'https://api.carthagent.xyz',
-          instructions: 'A legacy Carthagent Ship credential was found and will be migrated into OpenCode integration storage.',
+          instructions: 'A legacy Carthagent Cloud credential was found and will be migrated into native integration storage.',
           callback: Promise.resolve({
             type: 'oauth' as const,
             methodID: IntegrationSchema.MethodID.make(OAUTH_METHOD),
@@ -147,7 +146,7 @@ function oauthMethod({ env, fetchImpl, sleep, now, openBrowserImpl, agentDir, st
       Promise.resolve(openBrowserImpl(url)).catch(() => false);
       return {
         mode: 'auto' as const, url,
-        instructions: `Approve device code ${response.userCode} in your browser.`,
+        instructions: `Sign in and connect this terminal using code ${response.userCode}. Check the account shown in your browser, then return here. If the code expires, start login again.`,
         expiresAt: now() + Number(response.expiresIn || 600) * 1000,
         callback,
       };
@@ -169,13 +168,15 @@ function oauthMethod({ env, fetchImpl, sleep, now, openBrowserImpl, agentDir, st
         });
       },
     ),
-    label: () => 'Carthagent Ship',
+    label: () => 'Carthagent Cloud',
   };
 }
 
 function integrationDefinitions(editor: Parameters<Context['integration']['transform']>[0] extends (editor: infer E) => void ? E : never, options: Parameters<typeof oauthMethod>[0]) {
   editor.method.update(oauthMethod(options));
-  editor.method.update({ integrationID: IntegrationSchema.ID.make(SHIP_INTEGRATION_ID), method: { type: 'key', label: 'Use an Experiential API key' } });
+  if (options.env.CARTHAGENT_ADVANCED_AUTH === '1') {
+    editor.method.update({ integrationID: IntegrationSchema.ID.make(SHIP_INTEGRATION_ID), method: { type: 'key', label: 'Advanced: use an Experiential API key' } });
+  }
   editor.method.update({ integrationID: IntegrationSchema.ID.make(SHIP_INTEGRATION_ID), method: { type: 'env', names: [EXPERIENTIAL_API_KEY_ENV] } });
   editor.update(SHIP_INTEGRATION_ID, integration => { integration.name = EXPERIENTIAL_PROVIDER_NAME; });
 }
@@ -197,7 +198,7 @@ async function loadShipModels({ ctx, fetchImpl, env, baseURL, signal }: {
   const response = await fetchImpl(`${managed ? cloudGatewayUrl(env) : baseURL}/models`, {
     headers: { authorization: `Bearer ${key}` }, signal: signalWithTimeout(signal, DISCOVERY_TIMEOUT),
   });
-  if (!response.ok) throw new Error(`Carthagent Ship model discovery failed (${response.status}).`);
+  if (!response.ok) throw new Error(`Carthagent Cloud model discovery failed (${response.status}).`);
   const models = parseExperientialModels(await response.json()).slice(0, PROFILE_CAP);
   if (connection && managed) return { connection, models, managed };
   return { connection, models, managed };

package/plugins/carthagent/src/server/ship-rpc.ts

@@ -4,7 +4,7 @@ import type { ConnectionInfo } from '@opencode/client';
 
 type ShipContext = Pick<Context, 'integration'>;
 type ActiveCredential = Extract<ConnectionInfo, { type: 'credential' }>;
-type CloudClientPort = Pick<CloudClient, 'account' | 'usage' | 'checkout' | 'portal' | 'revokeCurrent' | 'revokeSession'>;
+type CloudClientPort = Pick<CloudClient, 'account' | 'usage' | 'quote' | 'checkout' | 'portal' | 'revokeCurrent' | 'revokeSession'>;
 
 /** Create profile-scoped Ship RPC handlers; injection keeps cloud behavior testable offline. */
 export function createShipRpcHandlers(ctx: ShipContext, options: {
@@ -15,10 +15,10 @@ export function createShipRpcHandlers(ctx: ShipContext, options: {
   const cloud = options.cloudClient ?? new CloudClient({ baseUrl: options.baseUrl ?? cloudControlUrl() });
   async function access() {
     const active = await ctx.integration.connection.active('experiential-labs');
-    if (!active || active.type !== 'credential' || active.method !== 'oauth') throw new Error('An active Carthagent Ship OAuth connection is required.');
+    if (!active || active.type !== 'credential' || active.method !== 'oauth') throw new Error('An active Carthagent Cloud OAuth connection is required.');
     const credential = await ctx.integration.connection.resolve(active);
     if (credential?.type !== 'oauth' || credential.methodID !== 'carthagent-device' || !credential.access) {
-      throw new Error('An active Carthagent Ship OAuth connection is required.');
+      throw new Error('An active Carthagent Cloud OAuth connection is required.');
     }
     return { active: active as ActiveCredential, token: credential.access };
   }
@@ -27,27 +27,29 @@ export function createShipRpcHandlers(ctx: ShipContext, options: {
       call.signal.throwIfAborted();
       let token: string;
       try { ({ token } = await access()); }
-      catch { return call.error('unauthenticated', 'An active Carthagent Ship OAuth connection is required.', {}); }
+      catch { return call.error('unauthenticated', 'An active Carthagent Cloud OAuth connection is required.', {}); }
       return { account: await cloud.account({ accessToken: token, signal: call.signal }) };
     },
     shipUsage: async (input: unknown, call: { signal: AbortSignal }) => {
       call.signal.throwIfAborted();
       const { token } = await access();
       const requested = (input as { limit?: number }).limit ?? 50;
-      if (!Number.isSafeInteger(requested) || requested < 1 || requested > 200) throw new Error('Ship usage limit must be between 1 and 200.');
+       if (!Number.isSafeInteger(requested) || requested < 1 || requested > 200) throw new Error('Cloud usage limit must be between 1 and 200.');
       return { usage: await cloud.usage({ accessToken: token, limit: requested, signal: call.signal } as Parameters<CloudClient['usage']>[0]) };
     },
     shipBilling: async (input: unknown, call: import('@opencode/plugin/promise/rpc').RpcCallContext<typeof import('../rpc').Carthagent.methods.shipBilling>) => {
       call.signal.throwIfAborted();
       let token: string;
       try { ({ token } = await access()); }
-      catch { return call.error('unauthenticated', 'An active Carthagent Ship OAuth connection is required.', {}); }
-      const action = (input as { action: 'checkout' | 'portal' }).action;
-      if (action !== 'checkout' && action !== 'portal') throw new Error('Unsupported Ship billing action.');
+      catch { return call.error('unauthenticated', 'An active Carthagent Cloud OAuth connection is required.', {}); }
+      const { action, plan = 'builder' } = input as { action: 'checkout' | 'portal' | 'quote'; plan?: string };
+      if (!['checkout', 'portal', 'quote'].includes(action)) throw new Error('Unsupported Cloud billing action.');
+      if (!['builder', 'pro', 'max'].includes(plan)) throw new Error('Choose Builder, Pro, or Max.');
+      if (action === 'quote') return { quote: await cloud.quote({ accessToken: token, plan, signal: call.signal }) };
       const returnUrl = `${options.cloudUrl ?? cloudControlUrl()}/account`;
       const result = action === 'portal'
         ? await cloud.portal({ accessToken: token, returnUrl, signal: call.signal })
-        : await cloud.checkout({ accessToken: token, successUrl: returnUrl, cancelUrl: returnUrl, signal: call.signal });
+        : await cloud.checkout({ accessToken: token, priceId: plan, successUrl: `${options.cloudUrl ?? cloudControlUrl()}/v1/browser/billing/complete`, cancelUrl: `${options.cloudUrl ?? cloudControlUrl()}/v1/browser/billing/cancelled?plan=${plan}`, signal: call.signal });
       return { url: result.url };
     },
     shipLogout: async (input: unknown, call: import('@opencode/plugin/promise/rpc').RpcCallContext<typeof import('../rpc').Carthagent.methods.shipLogout>) => {
@@ -55,7 +57,7 @@ export function createShipRpcHandlers(ctx: ShipContext, options: {
       let active: ActiveCredential;
       let token: string;
       try { ({ active, token } = await access()); }
-      catch { return call.error('unauthenticated', 'An active Carthagent Ship OAuth connection is required.', {}); }
+      catch { return call.error('unauthenticated', 'An active Carthagent Cloud OAuth connection is required.', {}); }
       const session = (input as { session?: string }).session;
       if (session) {
         await cloud.revokeSession({ accessToken: token, sessionId: session, signal: call.signal });

package/plugins/carthagent/src/tui.tsx

@@ -308,7 +308,7 @@ export default Plugin.define({
         }
         case "account": {
           const result = await shipClient(context, location).account() as { account: Record<string, unknown> };
-          await context.ui.dialog.alert({ title: "Carthagent Ship account", message: cloudAccountText(result.account) });
+          await context.ui.dialog.alert({ title: "Carthagent Cloud account", message: cloudAccountText(result.account) });
           return;
         }
         case "usage": {
@@ -316,24 +316,34 @@ export default Plugin.define({
             shipClient(context, location).account() as Promise<{ account: Record<string, unknown> }>,
             shipClient(context, location).usage({ limit: 50 }) as Promise<{ usage: Record<string, unknown> }>,
           ]);
-          await context.ui.dialog.alert({ title: "Carthagent Ship usage", message: cloudUsageText(usageResult.usage, accountResult.account) });
+          await context.ui.dialog.alert({ title: "Carthagent Cloud usage", message: cloudUsageText(usageResult.usage, accountResult.account) });
           return;
         }
         case "billing": {
-          const action = arg.toLowerCase() || "checkout";
-          if (!["checkout", "portal"].includes(action)) { toast("Usage: /billing [checkout|portal].", "warning"); return; }
-          const { url } = await shipClient(context, location).billing({ action: action as "checkout" | "portal" }) as { url: string };
+          const [action = "checkout", plan = "builder"] = arg.toLowerCase().split(/\s+/).filter(Boolean);
+          if (action === "refresh") {
+            const result = await shipClient(context, location).account() as { account: Record<string, unknown> };
+            await context.ui.dialog.alert({ title: "Cloud access refreshed", message: `${cloudAccountText(result.account)}\n\nYour task stays in this session. When usage is available, send “Continue the task” to resume.` });
+            return;
+          }
+          if (!["checkout", "portal"].includes(action) || !["builder", "pro", "max"].includes(plan)) { toast("Usage: /billing [checkout [builder|pro|max]|portal|refresh].", "warning"); return; }
+          if (action === "checkout") {
+            const { quote } = await shipClient(context, location).billing({ action: "quote", plan: plan as "builder" | "pro" | "max" }) as { quote: { terms: string; changingPlan: boolean } };
+            const proceed = await context.ui.dialog.confirm({ title: "Review Cloud plan", message: `${quote.terms}\n\n${quote.changingPlan ? "Review the exact proration in your browser before confirming the change." : "Continue to Stripe to review and pay."}\nYour task stays in this session. You can also connect your own provider with /login.` });
+            if (proceed !== true) return;
+          }
+          const { url } = await shipClient(context, location).billing({ action: action as "checkout" | "portal", plan: plan as "builder" | "pro" | "max" }) as { url: string };
           const { openBrowser } = await import("../../../lib/cloud/client.mjs");
           const opened = await openBrowser(url).catch(() => false);
-          await context.ui.dialog.alert({ title: action === "portal" ? "Ship billing portal" : "Ship checkout", message: `${opened ? "Opened in your browser." : "Open this URL in your browser:"}\n${url}` });
+          await context.ui.dialog.alert({ title: action === "portal" ? "Cloud billing portal" : "Cloud checkout", message: `${opened ? "Opened in your browser." : "Open this URL in your browser:"}\n${url}\n\nAfter payment, use /billing refresh. Your task stays here; send “Continue the task” when ready.` });
           return;
         }
         case "logout-cloud": {
           const session = arg || undefined;
-          const confirmed = await context.ui.dialog.confirm({ title: session ? "Revoke Ship session" : "Sign out of Carthagent Ship", message: session ? `Revoke Ship session ${session}?` : "Revoke the active Ship session and remove its Carthagent connection?" });
+          const confirmed = await context.ui.dialog.confirm({ title: session ? "Revoke Cloud session" : "Sign out of Carthagent Cloud", message: session ? `Revoke Cloud session ${session}?` : "Revoke the active Cloud session and remove its Carthagent connection?" });
           if (confirmed !== true) return;
           await shipClient(context, location).logout(session ? { session } : {});
-          toast(session ? `Revoked Ship session ${session}.` : "Revoked and removed the active Carthagent Ship connection.", "success");
+          toast(session ? `Revoked Cloud session ${session}.` : "Revoked and removed the active Carthagent Cloud connection.", "success");
           return;
         }
         case "archive": {

package/plugins/carthagent/src/ui/client.ts

@@ -95,7 +95,7 @@ export function shipClient(context: RpcContext, selectedLocation?: SelectedLocat
   return {
     account: (signal?: AbortSignal) => rpc.shipAccount({}, requestOptions(context, selectedLocation, signal)),
     usage: (input: { limit?: number } = {}, signal?: AbortSignal) => rpc.shipUsage(input, requestOptions(context, selectedLocation, signal)),
-    billing: (input: { action: "checkout" | "portal" }, signal?: AbortSignal) => rpc.shipBilling(input, requestOptions(context, selectedLocation, signal)),
+    billing: (input: { action: "checkout" | "portal" | "quote"; plan?: "builder" | "pro" | "max" }, signal?: AbortSignal) => rpc.shipBilling(input, requestOptions(context, selectedLocation, signal)),
     logout: (input: { session?: string } = {}, signal?: AbortSignal) => rpc.shipLogout(input, requestOptions(context, selectedLocation, signal)),
   };
 }

package/plugins/carthagent/src/ui/commands.ts

@@ -38,12 +38,12 @@ export const COMMANDS: readonly CarthagentCommand[] = [
   { id: "architecture", name: "architecture", description: "Open the delivery workspace architecture view" },
   { id: "evidence", name: "evidence", description: "Open observed delivery evidence" },
   { id: "login", name: "login", aliases: ["auth"], description: "Connect Ship, Claude, xAI, Codex/OpenAI, or Gemini" },
-  { id: "account", name: "account", aliases: ["cloud"], description: "Show Ship account, credits, plan, and sessions" },
+  { id: "account", name: "account", aliases: ["cloud"], description: "Show Cloud account, credits, plan, and sessions" },
   { id: "voyages", name: "voyages", description: "Open Voyages profile, wallet, equipment, shop, and daily quests" },
   { id: "quests", name: "quests", description: "Open daily coding quests; evidence requires separate explicit consent" },
   { id: "usage", name: "usage", description: "Show recent Ship usage from the control plane" },
   { id: "billing", name: "billing", args: "[checkout|portal]", description: "Open Ship checkout or billing portal" },
-  { id: "logout-cloud", name: "logout-cloud", args: "[session-id]", description: "Revoke a Ship session or sign out this profile" },
+  { id: "logout-cloud", name: "logout-cloud", args: "[session-id]", description: "Revoke a Cloud session or sign out this profile" },
   { id: "archive", name: "archive", args: "[search <query>|read <id>|export <id>]", description: "Browse bounded read-only archived sessions" },
   { id: "demo", name: "demo", description: "Run a scripted, provider-free delivery walkthrough" },
   { id: "ctg-workspace", name: "ctg-workspace", args: "[refresh]", description: "Browse and open local CTG workspace projects, tasks, and sessions" },

package/plugins/carthagent/src/ui/daily-quests.tsx

@@ -132,7 +132,7 @@ export function DailyQuestsPage(props: { sessionID?: string; questID?: string })
     const state = view(), detail = state.detail;
     const basic = [
       { name: "Refresh daily assignments and recovery journal", description: "Read-only; never uploads or replays evidence", value: "refresh" },
-      { name: "Sign in / reconnect", description: "Native Carthagent Ship device sign-in; not grading consent", value: "signin" },
+      { name: "Sign in / reconnect", description: "Native Carthagent Cloud device sign-in; not grading consent", value: "signin" },
       { name: "Back to Voyages", description: "Discard unsent editor contents", value: "back" },
     ];
     if (!state.snapshot) return basic;

package/plugins/carthagent/src/ui/voyages.tsx

@@ -60,7 +60,7 @@ export function VoyagesPage(props: { sessionID?: string; section?: "profile" | "
     const basic = [
       { name: "Refresh authoritative state", description: "Reload live profile and catalog", value: "refresh" },
       { name: "Daily coding quests", description: "Server assignments · selected evidence · explicit external JEV consent", value: "daily" },
-      { name: "Sign in / reconnect", description: "Native provider connection · choose Carthagent Ship device sign-in", value: "signin" },
+      { name: "Sign in / reconnect", description: "Native provider connection · choose Carthagent Cloud device sign-in", value: "signin" },
       { name: "Back", description: props.sessionID ? "Return to selected session" : "Return home", value: "back" },
       ...(props.section ? [{ name: props.section === "profile" ? "Equipment & shop" : "Profile & wallet", description: "Open the other Voyages detail view", value: "section" }] : []),
     ];

package/tests/cli.test.mjs

@@ -102,11 +102,11 @@ test('check fails clearly when no delivery report exists', t => {
   assert.match(result.stderr, /No delivery report/);
 });
 
-test('guidance routing is not a user-facing command and Ship account commands are documented', t => {
+test('guidance routing is not a user-facing command and Cloud account commands are documented', t => {
   const result = run(fixture(t), '--help');
   assert.equal(result.status, 0, result.stderr);
   assert.doesNotMatch(result.stdout, /\broute\b|\bprofiles\b/);
-  assert.match(result.stdout, /account.*Ship credit/);
+  assert.match(result.stdout, /account.*Cloud credit/);
   assert.match(result.stdout, /billing.*checkout\|portal/);
   assert.match(result.stdout, /logout-cloud/);
 });

package/tests/cloud-client.test.mjs

@@ -90,7 +90,7 @@ test('Cloud client sends account, billing, and session requests with bearer auth
 
 test('OAuth and account formatters keep token expiration and account UX deterministic', () => {
   assert.deepEqual(oauthCredentials({ accessToken: 'a', refreshToken: 'r', expiresIn: 900 }, 1_000), { access: 'a', refresh: 'r', expires: 901_000 });
-  assert.match(formatCloudAccount({ accountId: 'acct', balance: { availableNanoUsd: 1_000_000_000 }, subscription: { status: 'none' }, sessions: [{}, { revoked_at: 'x' }] }), /Credit: \$1\.00 available[\s\S]*Plan: Free[\s\S]*1 active, 1 revoked/);
+  assert.match(formatCloudAccount({ accountId: 'acct', balance: { availableNanoUsd: 1_000_000_000 }, subscription: { status: 'none' }, sessions: [{}, { revoked_at: 'x' }] }), /Credit: \$1\.00 available[\s\S]*Plan: No paid plan[\s\S]*1 active, 1 revoked/);
   const managed = formatCloudAccount({
     accountId: 'paid', balance: { availableNanoUsd: 8_000_000_000 },
     subscription: { status: 'active', current_period_end: 1_800_000_000 },
@@ -123,7 +123,7 @@ test('OAuth and account formatters keep token expiration and account UX determin
 test('managed usage recovery distinguishes daily, monthly, subscription, and credit paths', () => {
   assert.match(cloudManagedUsageRecovery('daily_limit_reached'), /00:00 UTC/);
   assert.match(cloudManagedUsageRecovery('monthly_allowance_exhausted'), /billing portal/);
-  assert.match(cloudManagedUsageRecovery({ code: 'subscription_inactive' }), /subscription is inactive/);
+  assert.match(cloudManagedUsageRecovery({ code: 'subscription_inactive' }), /awaiting payment or activation/);
   assert.match(cloudManagedUsageRecovery('insufficient_quota'), /billing checkout/);
   assert.equal(cloudManagedUsageRecovery('upstream timeout'), null);
 });

package/tests/experiential-extension.test.mjs

@@ -31,7 +31,7 @@ test('Cloud extension gives limit-specific recovery without hiding BYOK', () =>
   assert.equal(notices.length, 3);
   assert.match(notices[0][0], /00:00 UTC/);
   assert.match(notices[1][0], /billing portal/);
-  assert.match(notices[2][0], /subscription is inactive/);
+  assert.match(notices[2][0], /awaiting payment or activation/);
   assert.ok(notices.every(([, tone]) => tone === 'warning'));
-  assert.ok(notices.every(([message]) => /\/login for BYOK/.test(message)));
+  assert.ok(notices.every(([message]) => /\/login/.test(message) && /BYOK|your own provider/.test(message)));
 });

package/tests/experiential.test.mjs

@@ -272,7 +272,7 @@ test('registerExperientialProvider registers one shared provider definition', ()
   assert.equal(registerExperientialProvider(runtime), runtime);
   assert.equal(calls.length, 1);
   assert.equal(calls[0].id, 'experiential-labs');
-  assert.equal(calls[0].config.name, 'Carthagent Ship');
+  assert.equal(calls[0].config.name, 'Carthagent Cloud');
 });
 
 test('ModelRuntime resolves EXPLABS_API_KEY without copying it into provider config', async () => {

package/tests/native-provider-policy.test.mjs

@@ -8,7 +8,9 @@ test('native login policy stays small, named, ordered and excludes upstream prov
   assert.equal(nativeLoginProvider('opencode'), undefined);
   assert.equal(nativeLoginProvider('opencode-go'), undefined);
   assert.equal(nativeLoginProvider('openrouter'), undefined);
-  assert.equal(nativeProviderName('ship'), 'Carthagent Ship');
+  assert.equal(nativeProviderName('ship'), 'Carthagent Cloud');
+  assert.equal(nativeProviderName('Carthagent Ship'), 'Carthagent Cloud');
+  assert.equal(nativeProviderName('cloud'), 'Carthagent Cloud');
   assert.equal(nativeLoginProvider('claudecode').id, 'anthropic');
   assert.equal(nativeLoginProvider('codex').id, 'openai');
   assert.equal(nativeLoginProvider('gemini').id, 'google');
@@ -20,7 +22,7 @@ test('curated login rows preserve actual methods and do not invent subscription
   const ship = { id: 'experiential-labs', name: 'internal', methods: [{ type: 'oauth', id: 'carthagent-device' }] };
   const rows = nativeLoginProviders([{ id: 'opencode', methods: [] }, anthropic, ship]);
   assert.deepEqual(rows.map(row => row.id), ['experiential-labs', 'anthropic']);
-  assert.equal(rows[0].name, 'Carthagent Ship');
+  assert.equal(rows[0].name, 'Carthagent Cloud');
   assert.deepEqual(rows[1].methods, [{ type: 'key' }]);
   assert.equal(anthropic.name, 'Anthropic');
   assert.equal(ship.name, 'internal');

package/tests/native-ship-rpc.test.mjs

@@ -20,6 +20,7 @@ function setup() {
   const cloud = {
     account: async (input) => { calls.push(['account', input]); return { email: 'fixture@example.test', sessions: [] }; },
     usage: async (input) => { calls.push(['usage', input]); return { data: [{ alias: 'fixture-model', inputTokens: 12, outputTokens: 8 }] }; },
+    quote: async (input) => { calls.push(['quote', input]); return { introEligible: false, terms: 'Builder is $10/month until cancelled.' }; },
     checkout: async (input) => { calls.push(['checkout', input]); return { url: 'https://billing.example.test/checkout' }; },
     portal: async (input) => { calls.push(['portal', input]); return { url: 'https://billing.example.test/portal' }; },
     revokeCurrent: async (input) => calls.push(['revokeCurrent', input]),
@@ -47,7 +48,18 @@ test('Ship account and billing RPCs use the active profile credential and inject
     ['portal', 'fixture-token', true],
   ]);
   assert.ok(calls.some(([name, input]) => name === 'usage' && input.limit === 10));
-  assert.ok(calls.some(([name, input]) => name === 'checkout' && input.successUrl === 'https://ship.example.test/account'));
+  assert.ok(calls.some(([name, input]) => name === 'checkout' && input.successUrl === 'https://ship.example.test/v1/browser/billing/complete' && input.priceId === 'builder'));
+  await handlers.shipBilling({ action: 'checkout', plan: 'max' }, call);
+  assert.equal(calls.at(-1)[1].priceId, 'max');
+});
+
+test('native plan review uses authenticated server eligibility without creating checkout', async () => {
+  const { calls, handlers } = setup();
+  const result = await handlers.shipBilling({ action: 'quote', plan: 'builder' }, call);
+  assert.equal(result.quote.introEligible, false);
+  assert.equal(result.quote.terms, 'Builder is $10/month until cancelled.');
+  assert.ok(calls.some(([name, input]) => name === 'quote' && input.accessToken === 'fixture-token' && input.plan === 'builder' && input.signal === call.signal));
+  assert.equal(calls.some(([name]) => name === 'checkout'), false);
 });
 
 test('Ship logout revokes either one session or current token and removes current connection', async () => {
@@ -62,7 +74,7 @@ test('Ship logout revokes either one session or current token and removes curren
 test('Ship RPC requires its managed OAuth credential and honors cancellation before cloud traffic', async () => {
   const { ctx, calls, handlers } = setup();
   ctx.integration.connection.resolve = async () => ({ type: 'oauth', methodID: 'other', access: 'wrong' });
-  await assert.rejects(handlers.shipAccount({}, call), { code: 'unauthenticated', message: 'An active Carthagent Ship OAuth connection is required.' });
+  await assert.rejects(handlers.shipAccount({}, call), { code: 'unauthenticated', message: 'An active Carthagent Cloud OAuth connection is required.' });
   assert.equal(calls.some(([name]) => name === 'account'), false);
   const controller = new AbortController();
   controller.abort();

package/tests/opencode-cli.test.mjs

@@ -42,6 +42,40 @@ test('native CLI selects headless execution and preserves output-mode options',
   assert.equal(invocation.prompt, 'Do work');
 });
 
+test('headless continuation explains persistent budget exhaustion and resets only on explicit request', async t => {
+  const { mkdtempSync, rmSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const cwd = mkdtempSync(join(tmpdir(), 'ctg-budget-continuation-'));
+  t.after(() => rmSync(cwd, { recursive: true, force: true }));
+  const { io, output } = ioCapture();
+  const calls = [];
+  let stopped = 'elapsed-time';
+  const runtime = await createOpenCodeCliRuntime({ cwd, io, stdout: { write() {} }, native: {
+    runtime: {}, service: { ensureService: async () => ({}) }, rpcDefinitions: { Carthagent: {} },
+    clientFactory: async () => ({
+      rpc: () => ({ budgetStatus: async () => ({ stopped }) }),
+      session: {
+        list: async () => ({ data: [{ id: 'same-session', location: { directory: cwd } }] }),
+        get: async () => ({ id: 'same-session', location: { directory: cwd } }),
+        command: async input => { calls.push(input); stopped = null; },
+      },
+    }),
+    headless: { runHeadless: async (_service, _cwd, _prompt, options) => {
+      assert.equal(options.sessionID, 'same-session');
+      calls.push('prompt');
+      return { session: { id: 'same-session' }, outcome: stopped ? 'interrupted' : 'succeeded', terminal: true,
+        messages: stopped ? [] : [{ type: 'assistant', finish: 'stop', content: [{ type: 'text', text: 'continued' }] }] };
+    } },
+  } });
+  assert.equal(parseOpenCodeArgs(['--continue', '--reset-budget', 'Continue']).resetBudget, true);
+  assert.equal(await runtime.run({ mode: 'headless', options: { continue: true }, prompt: 'Continue' }), 1);
+  assert.match(output.stderr.at(-1), /budget exhausted: elapsed-time.*--reset-budget/);
+  assert.deepEqual(calls, ['prompt'], 'no implicit budget reset or prompt retry');
+  assert.equal(await runtime.run({ mode: 'headless', options: { continue: true, resetBudget: true }, prompt: 'Continue' }), 0);
+  assert.deepEqual(calls.slice(1), [{ sessionID: 'same-session', name: 'delivery-budget-reset', text: '' }, 'prompt']);
+  await assert.rejects(runtime.run({ mode: 'headless', options: { resetBudget: true }, prompt: 'New task' }), /requires --session/);
+});
+
 test('headless CLI validates prompts and maps cancellation to conventional exit code', async () => {
   const { io, output } = ioCapture();
   assert.equal(await runOpenCodeCli({ argv: [], stdoutIsTTY: false, io, runtime: {} }), 1);
@@ -77,10 +111,10 @@ test('model, auth, cloud and domain entrypoints dispatch to injected native capa
   ]);
 });
 
-test('help preserves command aliases, Ship operations and isolation semantics', async () => {
+test('help preserves command aliases, Cloud operations and isolation semantics', async () => {
   const { output, io } = ioCapture();
   assert.equal(await runOpenCodeCli({ argv: ['--help'], io, version: '1.0.3' }), 0);
-  assert.match(output.stdout[0], /account.*Ship credit/);
+  assert.match(output.stdout[0], /account.*Cloud credit/);
   assert.match(output.stdout[0], /billing.*checkout\|portal/);
   assert.match(output.stdout[0], /--isolate\s+Isolate extension\/skill discovery \(not a worktree\)/);
   assert.equal(cliHelp('x').includes('--engine-cli, --agent-cli'), true);
@@ -1011,8 +1045,8 @@ test('native Ship billing and logout explain how to connect when the typed auth
       shipLogout: async () => { throw Object.assign(new Error('Not authenticated'), { type: 'ship.unauthenticated' }); },
     }) }),
   } });
-  await assert.rejects(runtime.billing({ action: 'checkout' }), /not connected.*ctg login.*Carthagent Ship/i);
-  await assert.rejects(runtime.logout({}), /not connected.*ctg login.*Carthagent Ship/i);
+  await assert.rejects(runtime.billing({ action: 'checkout' }), /not connected.*ctg login.*Carthagent Cloud/i);
+  await assert.rejects(runtime.logout({}), /not connected.*ctg login.*Carthagent Cloud/i);
 });
 
 test('OAuth forms honor conditional fields, defaults, validation, and typed selections', async () => {

package/tests/opencode-providers.test.mjs

@@ -535,7 +535,7 @@ test('native sign-in starts fresh device authorization after opt-in legacy migra
   const browserUrls = [];
   let generation = 0;
   const cleanup = await registerProviders(fake.ctx, {
-    env: { CARTHAGENT_CLOUD_URL: 'https://cloud.test' }, agentDir: directory, now: () => 1000,
+    env: { CARTHAGENT_CLOUD_URL: 'https://cloud.test', CARTHAGENT_ADVANCED_AUTH: '1' }, agentDir: directory, now: () => 1000,
     openBrowser: url => { browserUrls.push(url); return false; },
     fetchImpl: async (url, init) => {
       requests.push({ url: String(url), body: JSON.parse(init.body) });
@@ -601,9 +601,10 @@ test('provider registration uses native provider transforms and cleanup; refresh
     openBrowser: () => false, requestSecret: 'test-secret',
   });
   assert.equal(typeof cleanup, 'function');
-  assert.deepEqual(fake.integrationTransforms[0].map(item => item.integrationID), ['experiential-labs', 'experiential-labs', 'experiential-labs']);
+  assert.deepEqual(fake.integrationTransforms[0].map(item => item.integrationID), ['experiential-labs', 'experiential-labs']);
   assert.equal(fake.integrationTransforms[0][0].method.id, 'carthagent-device');
-  assert.equal(fake.integrationTransforms[0][1].method.type, 'key');
+  assert.equal(fake.integrationTransforms[0][0].method.form, undefined, 'fresh sign-in has no migration question');
+  assert.equal(fake.integrationTransforms[0][1].method.type, 'env');
   assert.equal(fake.providerTransforms.find(item => item.info?.id === providerConstants.SHIP_PROVIDER_ID).info.package,
     '@opencode/ai/providers/openai-compatible');
   assert.ok(fake.hooks.some(item => item.name === 'http.request' && item.options.providerID === 'experiential-labs'));

package/tests/opencode-ship-rpc.test.mjs

@@ -40,7 +40,7 @@ test('profile Ship RPC uses resolved native OAuth and loopback account, billing,
       ['DELETE', '/v1/account/sessions/session-target'], ['POST', '/v1/token/revoke'],
     ]);
     assert.ok(requests.every(item => item.authorization === 'Bearer loopback-token'));
-    assert.deepEqual(requests[2].body, { successUrl: `${baseUrl}/account`, cancelUrl: `${baseUrl}/account` });
+    assert.deepEqual(requests[2].body, { successUrl: `${baseUrl}/v1/browser/billing/complete`, cancelUrl: `${baseUrl}/v1/browser/billing/cancelled?plan=builder`, priceId: 'builder' });
     assert.deepEqual(requests[3].body, { returnUrl: `${baseUrl}/account` });
     assert.deepEqual(removed, ['cred-profile']);
   } finally {
@@ -61,7 +61,7 @@ test('profile Ship RPC rejects BYOK, absent auth, and pre-aborted operations wit
       active: async () => connection,
       resolve: async () => connection ? { type: 'key', key: 'byok' } : undefined,
     } } }, { cloudClient });
-    await assert.rejects(handlers.shipAccount({}, rpcCall(new AbortController().signal)), /active Carthagent Ship OAuth/);
+    await assert.rejects(handlers.shipAccount({}, rpcCall(new AbortController().signal)), /active Carthagent Cloud OAuth/);
   }
   const handlers = createHandlers({ integration: { connection: { active: async () => undefined, resolve: async () => undefined } } }, { cloudClient });
   const controller = new AbortController();

package/tests/tui.test.mjs

@@ -36,7 +36,7 @@ test('Cloud managed-usage exhaustion is detected only for failed Cloud assistant
   assert.equal(isCloudCreditExhaustion({ type: 'message_end', message: { role: 'assistant', stopReason: 'error', errorMessage: 'credit is exhausted' } }, 'experiential-labs/model'), true);
   assert.match(cloudManagedUsageNotice({ type: 'message_end', message: { role: 'assistant', provider: 'experiential-labs', stopReason: 'error', errorMessage: '429: {"error":{"code":"daily_limit_reached"}}' } }), /00:00 UTC/);
   assert.match(cloudManagedUsageNotice({ type: 'message_end', message: { role: 'assistant', provider: 'experiential-labs', stopReason: 'error', errorMessage: 'monthly_allowance_exhausted' } }), /billing portal/);
-  assert.match(cloudManagedUsageNotice({ type: 'message_end', message: { role: 'assistant', provider: 'experiential-labs', stopReason: 'error', errorMessage: 'subscription_inactive' } }), /subscription is inactive/);
+  assert.match(cloudManagedUsageNotice({ type: 'message_end', message: { role: 'assistant', provider: 'experiential-labs', stopReason: 'error', errorMessage: 'subscription_inactive' } }), /awaiting payment or activation/);
   assert.equal(isCloudCreditExhaustion({ type: 'message_end', message: { role: 'assistant', provider: 'openai', stopReason: 'error', errorMessage: 'daily_limit_reached' } }), false);
   assert.equal(isCloudCreditExhaustion({ type: 'message_end', message: { role: 'assistant', provider: 'experiential-labs', stopReason: 'stop' } }), false);
 });
@@ -69,7 +69,7 @@ test('active model synchronization refreshes welcome blocks without redundant in
 
   syncActiveModel(state, feed, { provider: 'experiential-labs', id: 'gpt-6-luna' });
   assert.equal(state.model, 'experiential-labs/gpt-6-luna');
-  assert.equal(feed.blocks[0].model, 'Carthagent Ship/gpt-6-luna');
+  assert.equal(feed.blocks[0].model, 'Carthagent Cloud/gpt-6-luna');
 });
 
 const SAMPLE_PLAN = {

package/tools/native-fixture-stop-diagnostics.mjs

@@ -28,7 +28,9 @@ export async function fixtureStopDiagnostics({ child, output, elapsedMs }, { run
     ? ['-NoProfile', '-NonInteractive', '-Command', `$p = Get-Process -Id ${child.pid} -ErrorAction SilentlyContinue; if ($null -ne $p) { Write-Output ("pid={0} responding={1}" -f $p.Id, $p.Responding) }`]
     : ['-p', String(child.pid), '-o', 'pid=,ppid=,stat=,etime=,time='];
   try {
-    const { stdout } = await run(command, args, { timeout: 2000, maxBuffer: 4096, windowsHide: true });
+    // Cold PowerShell startup on shared Windows runners can exceed two seconds.
+    // Keep diagnostics bounded without mistaking startup latency for no process.
+    const { stdout } = await run(command, args, { timeout: windows ? 10000 : 2000, maxBuffer: 4096, windowsHide: true });
     const state = stdout.trim();
     // Only numeric process metadata and fixed state codes; never argv, names,
     // environment, stderr, database contents, or OS command error messages.

package/tools/native-terminal-semantics.py

@@ -488,7 +488,13 @@ def main():
                 visible = screen.visible().lower()
                 visible_original = screen.visible()
                 if 'connection lost' in visible or 'reconnecting to the server' in visible:
-                    raise RuntimeError(f'native host reconnect overlay during terminal acceptance: {visible_original!r}')
+                    # This isolated fixture is deleted on exit. Preserve its
+                    # bounded diagnostics in the failure rather than losing the
+                    # server-side reason with the temporary profile.
+                    logs = {str(log.relative_to(root)): log.read_text(errors='replace')[-12000:]
+                            for log in Path(root).rglob('*.log')}
+                    raise RuntimeError(f'native host reconnect overlay during terminal acceptance: '
+                                       f'{visible_original!r}; fixture logs={logs!r}')
                 home_ready = 'shift+tab agents' in visible and 'ctrl+p commands' in visible
                 onboarding_visible = ('connect opencode go' in visible or
                                       'connect an integration to' in visible or

package/tools/test-native-host.mjs

@@ -230,8 +230,10 @@ try {
   assert.ok(ship, 'the native provider catalog must supply a real Ship integration record');
   assert.ok(ship.methods.some(({ type, id }) => type === 'oauth' && id === 'carthagent-device'),
     'plugin integration transform must register the Ship device-OAuth method');
-  assert.ok(ship.methods.some(({ type }) => type === 'key'),
-    'plugin integration transform must register the Ship API-key method');
+  assert.equal(ship.methods.some(({ type }) => type === 'key'), false,
+    'fresh Cloud sign-in must hide the advanced API-key method');
+  assert.equal(ship.methods.find(({ type, id }) => type === 'oauth' && id === 'carthagent-device').form?.length ?? 0, 0,
+    'fresh Cloud sign-in must not prompt for legacy import');
   assert.ok(ship.methods.some(({ type, names }) => type === 'env' && names?.includes('EXPLABS_API_KEY')),
     'the native integration catalog resolves BYOK from the named environment credential');
   const models = await client.model.list({ location: { directory: cwd } }, request);

package/tools/test-native-ship-models.mjs

@@ -123,7 +123,7 @@ try {
   } while (Date.now() < deadline);
   console.log(JSON.stringify({ modelRequests, models: models.map(model => ({ id: model.id, providerID: model.providerID, connected: model.connected, status: model.status })) }));
   assert.ok(models.some(model => model.id === 'ctg-ship-fixture'), 'Successful Ship OAuth must publish discovered models in the real native model inventory without EXPLABS_API_KEY');
-  assert.equal(ship.name, 'Carthagent Ship', 'The connect picker must show the Ship name');
+  assert.equal(ship.name, 'Carthagent Cloud', 'The connect picker must show the Cloud name');
   assert.deepEqual(integrations.data.map(item => item.id).sort(), ['anthropic', 'experiential-labs', 'google', 'openai', 'xai'], 'Login must contain only the curated major integrations');
   const providers = (await client.provider.list({ location }, request)).data;
   assert.ok(!providers.some(provider => /^opencode(?:-|$)/.test(provider.id)), 'The upstream provider must not be available');