Skip to content

Remove Devstral 2 2512 from free models list - #21

Closed
kilo-code-bot[bot] wants to merge 5 commits into
mainfrom
remove-devstral-2512-free-model-cloud
Closed

Remove Devstral 2 2512 from free models list#21
kilo-code-bot[bot] wants to merge 5 commits into
mainfrom
remove-devstral-2512-free-model-cloud

Conversation

@kilo-code-bot

@kilo-code-bot kilo-code-bot Bot commented Feb 4, 2026

Copy link
Copy Markdown
Contributor

Summary

Remove Devstral 2 2512 (mistralai/devstral-2512:free) from the list of free models.

Changes

  • Remove devstral_2512_free_model from kiloFreeModels array in src/lib/models.ts
  • Remove devstral_2512_free_model export from src/lib/providers/mistral.ts
  • Update devstral_small_2512_free_model to be a standalone definition (no longer spreads from the removed model)
  • Remove mistralai/devstral-2512:free mapping from vercelModelIdMapping in src/lib/providers/vercel.ts

Context

The model at https://kilo.ai/models/mistralai-devstral-2512-free was listed as free but should no longer be offered for free.

Built for josh by Kilo for Slack

@kilo-code-bot
Remove Devstral 2 2512 from free models list
8ca0c57 
- Remove devstral_2512_free_model from kiloFreeModels array
- Remove devstral_2512_free_model export from mistral.ts
- Update devstral_small_2512_free_model to be standalone (no longer spreads from removed model)
- Remove mistralai/devstral-2512:free mapping from vercel.ts
@kilo-code-bot

kilo-code-bot Bot commented Feb 4, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor Author

Code Review Summary

Status: No Issues Found | Recommendation: Merge

Files Reviewed (3 files)
  • src/lib/models.ts
  • src/lib/providers/mistral.ts
  • src/lib/providers/vercel.ts

@chrarnoldus

chrarnoldus commented Feb 9, 2026

Copy link
Copy Markdown
Contributor

fine to clean this up, but I don't think it caused the described problem

@chrarnoldus
chrarnoldus deleted the remove-devstral-2512-free-model-cloud branch February 10, 2026 14:16
jrf0110 added a commit that referenced this pull request May 19, 2026
@jrf0110
feat(wasteland+web): stale-fork detection, sync CTA, accept idempoten…
7fc58cf 
…cy, browse reconciliation

Picks up from the v3 wl-sdk migration and lands a sweep of correctness
and UX fixes uncovered by end-to-end testing against real DoltHub data
(jrf0110/wl-commons upstream + jfawcett/wl-commons fork).

Key surfaces:

wl-sdk
  - publish: replace prior open/merged/closed PR-search idempotency
    with a tighter branch-HEAD-vs-main-HEAD comparison. Reusing a
    stale merged PR (e.g. the no-diff PR a `wl post` auto-publish
    leaves on the same `wl/<rig>/<id>` branch) shadowed fresh accept
    commits and made the UI report "merged" against the wrong PR.
    Now publish only reuses an open PR for the branch; a no-op is
    only returned when the branch tip already equals main.
  - browse: only flip `entry.source` to `'fork'` when the fork
    branch's `updated_at` is strictly newer than the upstream main
    row's. Fixes the post-accept-merge case where a stale
    `wl/<rig>/<id>` branch on the fork keeps shadowing `completed`
    upstream rows as `in_review`. Fork row stays attached for the
    drawer's branch tab.
  - state: new `readBranchHead` and `assertForkMainCurrent` helpers.
    Mutations now refuse with `code: 'precondition'` and a deep-link
    when fork main is behind upstream main (idempotent already-applied
    branches still short-circuit before the gate).
  - export `readBranchHead` from the package index.

wasteland service
  - getForkCurrency tRPC query: compares fork main HEAD vs upstream
    main HEAD without writing, returns a prefilled DoltHub
    `pulls/new` URL for the manual sync flow (DoltHub's API has no
    programmatic upstream→fork sync — the fork owner lacks write on
    the parent repo and CALL DOLT_FETCH/MERGE is blocked on hosted
    SQL).
  - acceptWantedItem rebuild: cross-fork reads via
    `submitterForkOwner`, threads `submitterPullId`/`completionId`/
    `evidence`/`submitterRigHandle`, all-in-one chain that writes
    adoption DML on admin's branch, merges admin's PR, closes the
    submitter's PR. Output now `{ success, pr_url, pr_id, merged,
    closed_submitter_pr }`.
  - markWantedItemDone now auto-publishes; output gained `pr_url`.
  - Inbox classifier: `dolthub_url` on InboxCardBase, `fork_owner`
    on InboxItem, SQL-trailer commit-message parsing for
    cloud-issued PRs (`Run SQL query: ... -- wl <verb>: <id>`).
    New 9-case inbox-classifier.test.ts.
  - debugErrorResponse surfaces the cause chain so accept/sync
    failures show the underlying DoltHub error in dev probes.
  - new debug endpoints: fork-currency, fork-sync-experiment
    (records the 14-probe rejection of every cross-repo path so
    future readers don't re-run the investigation).

apps/web
  - persistent Sync fork header CTA on both wasteland route trees
    (RepoDashboardHeader and WastelandDashboardHeader). Yellow when
    stale, muted when current; tooltip explains the manual flow and
    deep-links to a prefilled DoltHub pulls/new page using the
    `fromBranchOwner`/`fromBranchRepo`/`fromBranch`/`toBranch` query
    params Next.js exposes server-side.
  - SyncForkButton uses Radix tooltip primitives directly with
    popover tokens for dark-mode contrast (the shared ui/tooltip
    primitive uses bg-primary as a brand-yellow accent for short
    single-line tooltips).
  - Inbox row → drawer with inline AcceptForm for work-submission
    items; drawer EvidenceCard handles both URL and prose evidence
    with extractFirstUrl recovery for "PR submitted: <url>" inputs.
  - DoltHub integration page: drop the dev-only banner.
  - Navigation reorg: remove top-level Wastelands from personal +
    org sidebars; surface a Wastelands section on the personal
    /gastown overview; gate WastelandSettingsSection on
    `!organizationId`.

Tests
  - wl-sdk: 199 passing (added stale-fork browse case; updated
    overlay-with-fresh-fork test to use a strictly-newer
    updated_at; rewrote publish.test.ts to cover head-match no-op,
    open-PR reuse, and create-fresh-PR paths).
  - wasteland: 99 passing (added stale-branch browseViaSdk case;
    updated fork-currency fixtures across all mutation tests; fixed
    pre-existing 4 failures inherited from the M3 commit by
    aligning mocks with the new SDK fanouts).

Files this commit also picks up from the prior session's plan that
were left uncommitted (per SESSION_SUMMARY_2026-05-18.md): owner/repo
URL routing in the inbox card, gastown wasteland nav, M3.6 docs
sweep, accept-upstream submitter-fork fix, mayor `gt_wasteland_done`
URL-only constraint and gastown handler validation.

Verified end-to-end against the real DoltHub data:
  - Stale-fork claim attempt → 412 PRECONDITION_FAILED with deep
    link.
  - Re-running an admin accept after the prior PR merged → 200 with
    no-op pull id (no DoltHub 400).
  - First-time admin accept of jfawcett's `wl done` (PR #21) → fresh
    adoption PR #22 opened, merged, jfawcett's PR closed, upstream
    main has the wanted=completed + completion + stamp.
  - Browse on jfawcett's wasteland: previously-stale `in_review`
    items now correctly show `completed` from upstream after merge,
    independent of whether the local `wl/jfawcett/*` branch was
    discarded.
jrf0110 added a commit that referenced this pull request May 19, 2026
@jrf0110
feat(wasteland): admin review inbox, drawer graph navigation, rigs pa…
41d8dd6 
…ge filters (#2706)

* feat(wasteland): squash staging-v3 work into single commit

Collapses ~16 commits worth of wasteland-staging-v3 history (multiple
merges from main, the wasteland MVP, gastown integration deltas, and
the dolthub OAuth connect bridge) into a single tree-equivalent commit
on top of latest main.

Tree-equivalent to the previous wasteland-staging-v3 tip
(da22f25417d5967199a7ce7b7e0aca0b07b2aa2e). Pre-rewrite history
preserved on the wasteland-staging-v3-backup-* branches if recovery
is needed.

Source non-merge commits squashed into this one:
- feat(wasteland): connect with DoltHub via OAuth integration
- fix(wasteland): protect debug routes and org flow
- feat(wasteland): link beads to wanted items and auto-report done
- feat(wasteland): surface claim PR status, polish UI, bump wl to 0.4.0
- fix(wasteland): normalize DoltHub merge state casing
- chore: regenerate pnpm-lock.yaml after merge from main
- fix(wasteland): fail setUpstreamRigTrust when merge cannot be confirmed
- fix(wasteland): wait for merge before branch cleanup
- fix(wasteland): gate org-scoped routes on wasteland-access feature flag
- fix(wasteland): PR review findings + CI lint failures
- feat(wasteland): admin review inbox, drawer graph navigation, rigs UI

* feat(wasteland): three-card upstream picker + create-new-upstream end-to-end

Replaces the freeform `{owner}/{repo}` text input in both wasteland
onboarding surfaces (the standalone `/wasteland/new` wizard and the
Gastown wasteland-connect dialog) with a shared three-card chooser:

  1. Join the Kilo Commons          — fixed `hop/wl-commons`
  2. Connect to an existing upstream — typed + live verify probe
  3. Create a brand-new upstream    — typed + live availability check

Adds two dev-only tRPC procedures (`dolthub.verifyUpstream`,
`dolthub.resolveUsername`) plus matching service helpers. Verify uses a
two-stage probe (anonymous first, authenticated `/main` fallback) so
DoltHub's "Calls authenticated with a token must include a refName"
error doesn't fire on token-authed branchless calls. resolveUsername
hits `GET /api/v1alpha1/user` (which exists despite an earlier comment
claiming it didn't), caches the result, and replaces the manual
"enter your DoltHub username" prompt for first-time users.

Container fixes for the `Create new upstream` flow:

- `selfInit` probes upstream existence before `wl join` so a typo or
  not-yet-created repo no longer kicks the container into a crash loop.
- Boot-time `ensureInit()` catches rejection (was `void ensureInit()`,
  which surfaced as an unhandled promise rejection that Bun terminated
  the process on).
- `storeCredential` defers the `WL_UPSTREAM` push and `/wl/init` call
  when the upstream isn't on DoltHub yet, so the create-mode
  ordering (createWasteland → storeCredential → createUpstream) doesn't
  trigger `wl join` against a not-yet-existing repo.
- `handleCreate` runs `configureDolt` before `wl create` (otherwise
  `dolt init` errors with "Author identity unknown") and writes the
  same post-success local state `joinUpstream` does (synthetic
  wasteland config + `joined = true` + `WL_UPSTREAM`) so subsequent
  operations work without re-running `wl join`.

Tests: 8 new vitest cases on the wasteland-side `upstreamExistsOnDolthub`
probe; 11 new jest cases on the web-side `getDoltHubUser` /
`verifyDoltHubUpstreamExists` helpers; 7 new router tests covering
`resolveUsername` and `verifyUpstream` happy/failure paths and the
private-repo auth fallback.

* WIP wasm libwl

* wip(wasteland): worker-side bootstrap + UI refactor + DoltHub read fallback

Phase 1 of container retirement: createUpstream now bootstraps DoltHub
repos directly from the worker (services/wasteland/src/upstream-bootstrap/).
Adds createDatabase, execWrite with operation polling, mergeBranchIntoMain,
and the COMMONS_SCHEMA_STATEMENTS array hand-synced from
wasteland/schema/commons.sql. Bootstrap writes to a scratch branch then
merges to main because DoltHub silently no-ops first writes against
freshly-created DBs.

Phase 2: removed the remaining container call sites. containerStatus
synthesizes a static payload, containerJoin is a no-op, the worker's
debug routes call wantedBoard ops directly instead of going through
debugCallContainer, and the wasm-browse handler is deleted. Container
env-var sync removed from storeCredential.

Onboarding refactor (gastown WastelandSettingsSection + UpstreamIntent):
collapsed the join/create intent step, added a 'reuse' card backed by a
shadcn Select dropdown, default starts at new-details with intent
'commons'. Reuse short-circuits past credentials/identity steps.

Password-manager remediation: new SecretTokenInput component using
type=text + -webkit-text-security:disc + eye toggle to avoid Chrome's
save-password prompt. Manual-token forms wrapped in autoComplete=off
with anti-autofill attrs.

Bandaid for the 'no such repository' read failure (changes in
wasteland/internal/backend/remote.go committed separately): worker still
goes through libwl, but the Go side now retries reads anonymously when
DoltHub returns 404 or 4xx with that error body, which works around the
auth-path quirk on cross-org public reads.

53 tests pass; typecheck/lint/format clean.

* feat(wl-sdk): scaffold @kilocode/wl-sdk package

Skeleton for the new TypeScript wasteland protocol SDK that will replace
the libwl wasm bridge. No SDK logic yet \u2014 subsequent commits will fill
in the DoltHub client, DML helpers, ops, and WlClient wiring.

Part of the wasteland TS-SDK + three-place UI rebuild.

* feat(wl-sdk): port EscapeSQL/EscapeLIKE from wasteland Go SDK

Adds escapeSqlString, escapeSqlLike, escapeSqlIdentifier, sqlStringLiteral,
sqlStringOrNull, and sqlValue helpers in packages/wl-sdk/src/commons/escape.ts.
Byte-for-byte matches the Go reference in wasteland/internal/commons/commons.go.
Includes 24 vitest cases covering escape order, LIKE wildcards, identifier
escaping, and the empty-to-NULL convention used by the DML helpers.

* feat(wl-sdk): typed DoltHub HTTP client with anon-read fallback and polling

Adds packages/wl-sdk/src/dolthub/ (api, read, write, operation, branches,
pulls, database, index) with 70 vitest cases. Ports the working DoltHub
client from services/wasteland and the Go wasteland reference, including:

- Anonymous-read fallback on 404 or 4xx 'no such repository' \u2014 mirrors the
  doGet behavior in wasteland/internal/backend/remote.go
- Unified pollOperation supporting write, merge, and fork endpoints with
  the toCommitId-null quirk handling carried over from dolthub-write.ts
- Idempotent createBranch/createDatabase/forkDatabase
- Token never logged or exposed in errors; lowercase 'authorization: token'
  scheme as DoltHub requires
- Discriminated DoltHubAuth union forces explicit anonymous reads
- Each function accepts an injectable fetch (and sleep for poll loops)
  for hermetic tests

The existing services/wasteland/src/util/dolthub-api.util.ts and
upstream-bootstrap/dolthub-write.ts remain in place for now \u2014 the SDK is
gated behind a (yet-to-land) feature flag in M1.8.

* feat(wl-sdk): schema generator with DML helpers from commons.sql

Adds packages/wl-sdk/scripts/generate-from-schema.ts and sql-parser.ts which
read wasteland/schema/commons.sql and emit:

- packages/wl-sdk/src/commons/schema.generated.ts \u2014 Zod row schemas, table
  metadata, and COMMONS_SCHEMA_STATEMENTS for the 9 commons tables.
- packages/wl-sdk/src/commons/dml.generated.ts \u2014 11 DML helpers ported from
  wasteland/internal/commons/commons.go, including formatTagsJson and a
  formatNowUtc helper that matches Go's time.Format('2006-01-02 15:04:05').

DML output matches the Go reference byte-for-byte (verified by hand-trace on
claim/submit/insert/update/delete/accept/close/reject and asserted in 22
vitest cases). insertWantedDML defaults priority to 0 when unset to match
Go's int zero-value, not the SQL column's DEFAULT 2 \u2014 the DML always writes
an explicit value, so the DB default never kicks in.

Drift management:
- pnpm --filter @kilocode/wl-sdk generate regenerates from the canonical SQL.
- pnpm --filter @kilocode/wl-sdk generate:check fails CI on uncommitted drift.
- Generator path defaults to ../wasteland; override via WASTELAND_REPO_PATH.
- Generated files pass through oxfmt --ignore-path /dev/null so they stay
  formatted (oxfmt would otherwise skip *.generated.* per .prettierignore).

* feat(wl-sdk): protocol ops layer (claim, post, browse, join, publish, ...)

Adds packages/wl-sdk/src/ops/* and packages/wl-sdk/src/commons/registration.ts:

Shared primitives:
- types.ts \u2014 MutationContext, MutationResult, WlError envelope
- branch.ts \u2014 makeWlBranch / parseWlBranch (wl/<rig>/<id>, wl/register/<rig>)
- state.ts \u2014 read branch + main wanted state, equivalence check
- mutate.ts \u2014 generic 'apply DML to fork branch' primitive: branch creation,
  idempotency check, optional auto-cleanup-on-revert. Mirrors mutatePR in
  wasteland/internal/sdk/mutate.go but does NOT auto-create PRs (that is the
  deliberate behavior change called out in the plan).

Mutations: claim, unclaim, done, post, accept, reject, close.
Reads: browse (branch-aware overlay over main).
Lifecycle: join (fork + register-branch + registration PR), leave (shallow
\u2014 deletes wl/<rig>/* branches only; rig deregistration is a known gap).
Branch lifecycle: publish (open PR for branch), unpublish (close PR, keep
branch), workshop (listMyBranches, discardBranch).

commons/registration.ts ports BuildRegistrationSQL from
wasteland/internal/commons/registration.go with a byte-for-byte test.

170 vitest cases total in the package. Two deliberate divergences from Go
are documented inline:
- Idempotency check skips when branchStatus == targetStatus (the plan), not
  Go's branchStatus == targetStatus && branchStatus != mainStatus.
- accept does not perform Go's self-stamp guard or completion lookup; the
  caller passes stamp.subject directly. Application policy lives at the
  caller, not the SDK.

* feat(wl-sdk): WlClient class and finalized public surface

Wires the ops layer into the top-level WlClient described in the plan:

  const wl = new WlClient({ upstream, forkOrg, rigHandle, token,
                            onRequest, onError, fetch, now });
  await wl.join({...});
  await wl.claim(wantedId);
  await wl.publish(wantedId);

Methods are thin wrappers that build a MutationContext from config and
delegate to packages/wl-sdk/src/ops/*. onRequest/onError hooks are threaded
through the dolthub layer.

Also finalizes packages/wl-sdk/src/index.ts as the package's public surface
\u2014 WlClient, every ops result/input type, the SQL escape helpers, the
generated DML helpers and row schemas, COMMONS_SCHEMA_STATEMENTS, branch
name helpers, WlError, and DOLTHUB_API_BASE/DOLTHUB_WEB_BASE.

186 vitest cases passing (+5 for client wiring). The previous libwl path in
services/wasteland is unchanged \u2014 the SDK will be wired in behind a
useWlSdk feature flag in M1.8.

* feat(wasteland): wire wl-sdk into tRPC behind WL_SDK_ENABLED flag

M1.8 \u2014 the wl-sdk now serves the 8 wanted-board ops (claim, unclaim, post,
done, accept, reject, close, browse) when the WL_SDK_ENABLED env var is
truthy. Default is off; libwl path is unchanged.

  services/wasteland/src/wanted-board/feature-flag.ts \u2014 useWlSdk(env) helper
    reads WL_SDK_ENABLED ('1'/'true'/'yes'/'on'). Single source of truth.
  services/wasteland/src/wanted-board/dispatcher.ts \u2014 dispatch{Browse,Claim,
    \u2026} per-op routing. tRPC procedures call these instead of the libwl
    helpers directly.
  services/wasteland/src/wanted-board/wanted-board-ops-sdk{,-inner}.ts \u2014 the
    SDK adapter. Resolves DoltHub auth (fresh OAuth \u2192 stored PAT, mirroring
    the existing loadContext precedence), constructs a WlClient, calls the
    op, maps the result back to the legacy tRPC return shape so apps/web
    types are unchanged.
  services/wasteland/src/wanted-board/errors.ts \u2014 WantedBoardOpError lifted
    out of wanted-board-ops.ts so both paths share the error class.
  services/wasteland/wrangler.jsonc, worker-configuration.d.ts \u2014 declare
    WL_SDK_ENABLED as a string env var, default '0'.

Adapter mapping notes:
- claim splits the libwl 'claim+auto-PR' single call into wl.claim then
  wl.publish. The PR URL flows back into the existing pr_url field.
- accept reads the latest completion id off the user's branch (the SDK
  takes completionId explicitly; libwl looked it up implicitly).
- post synthesizes a w-<hex12> id since the SDK does not own id generation.
- direct (wild-west) mode is silently downgraded to PR mode under the SDK
  path \u2014 the SDK has no upstream-direct write path. Documented in code.

68/68 wasteland service tests pass. 186/186 wl-sdk tests pass. Both
typecheck and lint clean. apps/web types unchanged.

* feat(wasteland): owner/repo lookup via registry + resolveOwnerRepo procedure

M2.1 \u2014 lays the foundation for the new /wasteland/:owner/:repo routes
without churning every tRPC procedure to take owner/repo. New routes will
call resolveOwnerRepo once at the page boundary, then pass the resolved
wastelandId to every existing procedure unchanged.

Registry changes (services/wasteland/src/dos/wasteland-registry/registry-ops.ts):
- wasteland_registry table grows a nullable dolthub_upstream column with a
  case-insensitive index.
- ALTER is idempotent for existing DOs (catches 'duplicate column').
- New methods: findByOwnerRepo (case-insensitive via lower()),
  setDolthubUpstream, backfillDolthubUpstream.
- findByOwnerRepo orders by created_at DESC LIMIT 1 \u2014 if two wastelands
  point at the same upstream, the newest wins. Documented; not enforced
  via uniqueness constraint.

Router wiring (services/wasteland/src/trpc/router.ts):
- createWasteland and createUpstream write dolthub_upstream into the
  registry alongside config.
- updateWastelandConfig calls setDolthubUpstream when the upstream changes.
- New wasteland.resolveOwnerRepo({owner, repo}) query returns the resolved
  wastelandId or null. No auth check \u2014 caller layers auth via downstream
  procedures.

Server helper (services/wasteland/src/trpc/resolve-wasteland.ts):
- Unit-testable resolveWastelandWith(registry, args) +
  resolveWasteland(env, args) production entry point.

Backfill (services/wasteland/src/wasteland.worker.ts):
- POST /debug/registry/backfill-upstreams behind cfAccessDebugMiddleware,
  iterates every wasteland and re-syncs its registry upstream from per-DO
  config. Idempotent.

apps/web type mirror updated. 81/81 wasteland tests pass (+13 new).

* feat(web): owner/repo-keyed wasteland routes with three-place navigation

M2.2 \u2014 introduces /wasteland/[owner]/[repo] as the new default landing route
for a wasteland, alongside placeholders for /fork, /pulls, /settings.

Route restructure:
- Legacy tree moved from /wasteland/[wastelandId]/* to
  /wasteland/by-id/[wastelandId]/* so it doesn't collide with the new
  [owner]/[repo] dynamic segment at the same depth.
- Two beforeFiles rewrites in apps/web/next.config.mjs match
  /wasteland/<uuid>/* and rewrite to /wasteland/by-id/<uuid>/*. URLs in
  the browser stay unchanged \u2014 every existing UUID-keyed link still
  resolves through the rewrite. M2.8 will replace the rewrite with a
  redirect to the new owner/repo URL.
- Side benefit: /wasteland/<single-non-uuid-segment> now 404s instead of
  hitting the legacy redirect chain.

New tree (apps/web/src/app/(app)/wasteland/[owner]/[repo]/):
- layout.tsx \u2014 server-side gate + tRPC provider + drawer stack + page
  header context.
- _components/RepoLayoutShell \u2014 calls wasteland.resolveOwnerRepo to map
  owner/repo \u2192 wastelandId. If null, renders NotConnectedShell with a
  Connect CTA (anonymous-browse path is deferred to a later milestone,
  surfaced as a disabled tooltipped button).
- _components/RepoDashboardHeader \u2014 mono <owner>/<repo> + visibility
  badge + per-page subtitle.
- _components/RepoNavTabs \u2014 four real <Link> tabs (Upstream / Fork /
  Pulls / Settings) with usePathname-driven active state.
- page.tsx \u2014 the upstream landing view. Reuses WantedBoardClient in
  read-only 'upstream' mode (no Post button, no mutation dialogs, drawer
  opens with actions:null). Each row gains a 'Take to my workshop' hover
  affordance pointing at /wasteland/[owner]/[repo]/fork?wantedId=<id>.
- fork/page.tsx, pulls/page.tsx, settings/page.tsx \u2014 placeholders tagged
  with TODO M2.3/M2.4/M2.5.

WantedBoardClient now accepts mode='fork'|'upstream', workshopBasePath,
and headerTitle props. mode='upstream' hides Post, suppresses every
mutation dialog, and renders the workshop-handoff link.

Resolved import paths in the org-scoped tree to point at the new
/by-id/[wastelandId]/* legacy location.

* feat(wasteland+web): fork workshop view and pulls view at owner/repo routes

M2.3 + M2.4 \u2014 implements the second and third 'places' from the plan:
  /wasteland/[owner]/[repo]/fork   \u2014 your fork / workshop
  /wasteland/[owner]/[repo]/pulls  \u2014 PRs in flight (mine + incoming)

New tRPC procedures (services/wasteland/src/trpc/router.ts):
  wasteland.listMyForkBranches({wastelandId}) \u2192 ForkBranchEntry[]
  wasteland.discardBranch({wastelandId, wantedId}) \u2192 {success}
  wasteland.publishBranch({wastelandId, wantedId}) \u2192 {prUrl, prId}
  wasteland.listMyPulls({wastelandId}) \u2192 MyPullEntry[]

All four are SDK-only (no libwl path \u2014 these operations are new). Live
in services/wasteland/src/branch-ops/{branch-ops, branch-ops-inner}.ts
following the same split-by-injectability pattern as the wanted-board
SDK adapter (inner is pure + fetch-injectable; outer resolves auth and
binds to the worker context). 7 new vitest cases cover happy path and
edge cases for each op (88 total wasteland tests, +7).

apps/web new clients:
  /fork ForkClient.tsx \u2014 lists wl/<rig>/* branches with divergence chip,
    PR badge, and inline Continue / Publish / Discard actions. Empty
    state copy per the plan: 'No work in flight. Browse the upstream
    and claim something to start a branch on your fork.'
  /pulls PullsClient.tsx \u2014 Mine + Incoming tabs. Incoming is hidden
    unless the caller is a maintainer (trust_level >= 2 OR
    is_upstream_admin OR site admin \u2014 the broader check is documented
    inline since admins shouldn't be locked out of their own queue).
    Reuses mergeUpstreamPR / closeUpstreamPR / commentOnUpstreamPR.

Hand-mirrored type signatures in apps/web/src/lib/wasteland/types/router.d.ts
per the established README convention.

listMyPulls fan-out is capped at MY_PULLS_DETAIL_CAP = 100 because
DoltHub's pull-list endpoint omits creator_name; documented inline.
listMyForkBranches uses the wl-sdk's listMyBranches helper which
itself does N detail reads \u2014 acceptable for M2, target for caching.

* feat(web): settings page at /wasteland/[owner]/[repo]/settings

M2.5 \u2014 ports the legacy SettingsClient onto the new owner/repo route tree.

  apps/web/src/app/(app)/wasteland/[owner]/[repo]/settings/SettingsClient.tsx
  apps/web/src/app/(app)/wasteland/[owner]/[repo]/settings/layout.tsx (scroll
    viewport with a route-scoped id so the legacy scrollspy doesn't collide)

Sections kept (5):
  General       \u2014 name, visibility, read-only dolthub upstream display
                  (the URL is now the address; settings shows it but does
                  not let you edit it). Admin self-attest checkbox stays.
  DoltHub Connection
  Connected Towns
  Admin Access  \u2014 admin-only verifyUpstreamAdmin
  Danger Zone   \u2014 owner-only delete with type-to-confirm

Section dropped: Wasteland Connection (containerStatus / Phase-2 retirement
block from the legacy file). The wl-sdk path no longer exposes that
information; the legacy SettingsClient under by-id/ is unchanged.

The new client reads wastelandId from useWastelandRepo() (the layout's
context) instead of URL params, so adding/removing route segments does
not require touching this code.

Legacy tree at apps/web/src/app/(app)/wasteland/by-id/[wastelandId]/settings/
remains untouched and continues to serve via the next.config rewrites
until M2.8 cuts the legacy URLs over to redirects.

* feat(web): item drawer with three-tab anchor (Upstream / My branch / Pull request)

M2.6 \u2014 reshapes the wanted-item drawer to mirror the plan's three places.

  apps/web/src/components/wasteland/drawer/WantedItemPanel.tsx \u2014 rewritten
    as a tabs shell. Reads listMyForkBranches and listMyPulls (filtered to
    this item) to decide which tabs to show. initialTab prop selects the
    default tab based on where the drawer was opened from.
  apps/web/src/components/wasteland/drawer/WantedItemUpstreamTab.tsx \u2014 the
    read-only upstream snapshot.
  apps/web/src/components/wasteland/drawer/WantedItemBranchTab.tsx \u2014 branch
    state + stacked actions (claim/done/unclaim/accept/reject/close per
    state and admin gate) + Publish (primary CTA when no PR) / Update PR
    (when PR exists, idempotent) / Discard (inline confirm).
  apps/web/src/components/wasteland/drawer/WantedItemPullTab.tsx \u2014 PR title,
    state, mergeable badge, link to DoltHub, maintainer-only Merge/
    Comment/Close.

Tab visibility:
  Upstream      always
  My branch     visible only when caller has wl/<rig>/<wantedId>, OR while
                loading. Hidden in cross-reference (actions=null) mode.
  Pull request  visible only when an open PR exists for that branch.

initialTab routing:
  WantedBoardClient (legacy + new upstream view) \u2192 'upstream' or 'branch'
    depending on isUpstream.
  ForkClient \u2192 'branch'.
  PullsClient is unchanged (PRs go to DoltHub directly today).

Pending-claims polling and the existing claim mutation are preserved.

Drawer width unchanged at 620px; the three triggers fit comfortably.

No new tRPC procedures \u2014 the existing listMyForkBranches/listMyPulls are
sufficient and filtering one entry from the small list is cheaper than
adding a new endpoint.

apps/web/src/components/wasteland/drawer/types.ts gains a WantedItemTab
union and an optional initialTab field on the wanted-item drawer refs.

* feat(wasteland+web): explicit fork-and-register connect ceremony

M2.7 \u2014 makes the join ceremony visible to the user. Today's wizard creates
a wasteland record but the actual fork and rig registration happen
opaquely or not at all. The plan calls for a deliberate ritual.

New tRPC procedure (services/wasteland/src/lifecycle-ops/lifecycle-ops.ts):

  wasteland.joinWasteland({wastelandId, rigHandle, rigDisplayName?, rigEmail?})
    \u2192 {forkOwner, forkRepo, forkUrl, rigHandle, registrationBranch,
        registrationPullId, registrationPullUrl, alreadyJoined}

Calls WlClient.join() to fork, wait, INSERT the rig registration, push
wl/register/<handle>, and open the registration PR. Persists credentials
with the verified rig handle. Idempotent end-to-end (the fork already
exists \u2192 forkCreated:false; ON DUPLICATE KEY UPDATE on registration; the
publish step finds and returns the existing PR by title). 2 new vitest
cases cover happy path and idempotent path.

Wizard rewrite (apps/web/src/app/(app)/wasteland/new/NewWastelandWizardClient.tsx):

  commons / connect intents now run a 5-step flow:
    1. Intent (name/ownership/upstream/visibility)
    2. DoltHub credentials (OAuth or PAT)
    3. Rig handle (smart default = DoltHub username, validated)
    4. Fork preview \u2014 the deliberate transparency step. Shows exactly:
         'Connecting to <upstream> will:
          1. Fork the upstream to <dolthubOrg>/<repo>
          2. Register your rig <handle> via a pull request
          3. Set up this wasteland in Kilo'
    5. Success \u2014 fork URL, rig handle, registration PR link, CTAs to
       'Browse the upstream' and 'Visit wasteland'.
  create intent: unchanged 3-step (intent \u2192 work \u2192 success).
  reuse intent: skips credentials/rig/preview entirely.

Failure modes handled inline: 401/403 detected via 'unauthor*'/'forbidden'
patterns surface a 'fork manually' link to dolthub.com/repositories/<...>
plus Retry. Generic errors get a Retry button. Retries reuse the already-
created wastelandId (pendingWastelandId state) so a join failure on attempt
two doesn't create a duplicate wasteland record. Editing any of the
createWasteland inputs clears pendingWastelandId so a fresh start really
starts fresh.

URL pre-fill: /wasteland/new?upstream=<owner>/<repo> seeds the intent
picker (used by NotConnectedShell from M2.2 and any deep link).

Gastown WastelandSettingsSection has a minimal change \u2014 it now calls
joinWasteland after storeCredential to actually fork-and-register, not
just record the connection. Full UI rewrite to match the standalone 5-step
wizard is left as a follow-up TODO.

apps/web/src/lib/wasteland/types/router.d.ts hand-mirrors the procedure.
90 wasteland service tests pass (+2). 186 wl-sdk tests pass.

* feat(web): redirect legacy UUID wasteland URLs to owner/repo URLs

M2.8 \u2014 closes the migration loop. Legacy /wasteland/<uuid>/... URLs now
server-side redirect (308) to the new /wasteland/<owner>/<repo>/... URLs
when the wasteland has a stored dolthub_upstream. URLs without an upstream
fall through to the existing legacy UI as a soft-failure landing pad
(users can configure an upstream from settings to enable redirects).

Path mapping:
  /wasteland/<uuid>          \u2192 /wasteland/<owner>/<repo>
  /wasteland/<uuid>/wanted   \u2192 /wasteland/<owner>/<repo>
  /wasteland/<uuid>/rigs     \u2192 /wasteland/<owner>/<repo>/settings (no rigs
                                tab in new tree \u2014 surface in settings for
                                now; dedicated section is a follow-up)
  /wasteland/<uuid>/members  \u2192 /wasteland/<owner>/<repo>/settings
  /wasteland/<uuid>/claims   \u2192 /wasteland/<owner>/<repo>/fork
  /wasteland/<uuid>/review   \u2192 /wasteland/<owner>/<repo>/pulls
  /wasteland/<uuid>/settings \u2192 /wasteland/<owner>/<repo>/settings

Org-scope routes (/organizations/<id>/wasteland/<uuid>/...) flatten to
the same personal-scope new URLs \u2014 org membership is enforced at the
worker layer, so the URL doesn't have to encode the org id.

Implementation:
  apps/web/src/lib/wasteland/server-resolve.ts \u2014 server-only helper that
    mints a 5-min JWT via generateApiToken, calls the worker's getWasteland
    via httpLink (single shot, not batched), parses dolthub_upstream as
    <owner>/<repo>. Try/catch returns null on any failure so a redirect
    lookup that 500s never blocks the legacy fallback.
  apps/web/src/lib/wasteland/upstream.ts \u2014 isomorphic parseDolthubUpstream
    helper shared between server-resolve and the personal/org list clients.
  Each legacy page.tsx (14 total) calls auth gate first, then resolves
    upstream, then redirects when present, otherwise falls back to the
    existing client component.
  List clients link items to /wasteland/<owner>/<repo> when upstream is
    set, otherwise to the legacy UUID URL.

next.config.mjs rewrites /wasteland/<uuid>/... \u2192 /wasteland/by-id/<uuid>/...
remain in place \u2014 they're still required to make the legacy by-id/ tree
reachable via the original URLs, which is the redirect's job to convert.

* chore(wasteland): delete libwl, container runtime, and WL_SDK_ENABLED flag

M3.1 + M3.2 + M3.5 \u2014 the SDK is now the only path; libwl wasm and the
Cloudflare Container runtime are gone.

Deleted:
  services/wasteland/src/wasm/                          (libwl + go runtime)
  services/wasteland/container/                         (Dockerfile + control)
  services/wasteland/src/wanted-board/wanted-board-ops.ts (libwl bridge)
  services/wasteland/src/wanted-board/dispatcher.ts     (flag dispatcher)
  services/wasteland/src/wanted-board/feature-flag.ts   (useWlSdk helper)
  services/wasteland/src/dos/WastelandContainerDO.stub.ts
  services/wasteland/docs/wasm-poc.md

tRPC procedures removed: containerStatus, containerJoin (no callers in
apps/web after M2.5).

Debug routes removed: /debug/wastelands/:id/container/{config,health}.

Wrangler config: containers block dropped, WL_SDK_ENABLED env var dropped.
DO binding WASTELAND_CONTAINER and the v1 migration entry are kept \u2014 v3
will drop the class via deleted_classes (M3.3).

WastelandContainer.do.ts rewritten as a minimal DurableObject stub so the
class still resolves for the binding; no @cloudflare/containers import.

apps/web type mirror (router.d.ts) no longer references the deleted
procedures. Legacy SettingsClient lost its containerStatus section.

The 8 wanted-board ops in services/wasteland/src/trpc/router.ts now call
the SDK adapter (browseViaSdk, claimViaSdk, etc.) directly. No more flag
dispatcher.

Tests: 186 wl-sdk, 86 wasteland (down from 90 \u2014 deletion matches the
4 dispatcher/feature-flag cases that no longer have a target). All pass.

Stale comments and docs that reference libwl / WL_SDK_ENABLED / the
container runtime are intentionally left in place for M3.6 to clean up
in a single doc-and-comment pass.

* chore(wasteland): v3 migration drops WastelandContainerDO + remove wanted_board cache

M3.3 + M3.4 \u2014 final structural cleanup. The container DO is fully retired
and the vestigial wanted-board cache is gone.

DO migration (services/wasteland/wrangler.jsonc):
  v3 adds deleted_classes: ['WastelandContainerDO']. The Cloudflare
  Container backing this class is gone (Phase 2 of the container
  retirement). The DO carried no load-bearing state, so tombstoning
  any surviving instances on next deploy is intentional and
  irreversible \u2014 once a class is in deleted_classes the platform
  treats it as gone.

  WASTELAND_CONTAINER binding removed from prod and dev env stanzas.

Files deleted:
  services/wasteland/src/dos/WastelandContainer.do.ts (the stub class)
  services/wasteland/src/dos/wasteland/wanted-board.ts
  services/wasteland/src/db/tables/wasteland-wanted-board.table.ts

Wasteland.do.ts loses:
  - getWantedBoard / refreshWantedBoard RPC methods
  - createTableWastelandWantedBoard initialization
  - the WantedItemResult type

Callers cleaned (8 sites): each of claim/unclaim/post/done/accept/
reject/close/discardBranch in the SDK adapters used to call
ctx.doStub.refreshWantedBoard() after a successful write \u2014 a no-op
against a never-written cache. Removed.

Debug routes: /debug/wastelands/:id/wanted is gone (it was reading
the empty cache). The status route's response no longer includes
wantedBoardCount (it was always 0).

worker-configuration.d.ts regenerated with wrangler types
--include-runtime=false; the two hand-authored SENTRY_DSN/
SENTRY_RELEASE lines are preserved.

Tests: 186 wl-sdk, 86 wasteland \u2014 unchanged. Typecheck and lint clean.

Out-of-scope follow-up: services/gastown/src/util/wasteland-client.util.ts
exposes a refreshWantedBoard tRPC client method that pointed at a
mutation that never existed on the wasteland router. Now provably dead;
remove in a gastown-scoped follow-up.

* docs(wasteland): final M3.6 sweep \u2014 docs and stale comments

Final cleanup pass to satisfy the plan's acceptance criteria:

  rg 'libwl|callLibwl|LibwlOp'           services/wasteland/src/  empty
  rg 'WL_SDK_ENABLED|useWlSdk'           services/wasteland/src/  empty
  rg '@cloudflare/containers'            services/wasteland/      empty
  rg 'wasteland_wanted_board'            services/wasteland/      empty
  rg 'containerStatus|containerJoin'     services/wasteland/src/  empty
  rg 'container/'                        services/wasteland/      empty
  rg 'WastelandContainerDO'              services/wasteland/      only the
                                                                  immutable
                                                                  wrangler
                                                                  migration
                                                                  history (v1
                                                                  new_sqlite +
                                                                  v3 deleted)

Comment rewrites in services/wasteland/src/ (10 files): each touch either
removes a now-meaningless reference (libwl, WL_SDK_ENABLED, the container,
the deleted wanted-board cache) or rewrites it to describe the current
architecture. Notable callouts:
  - branch-ops/{branch-ops,branch-ops-inner}.ts and lifecycle-ops/
    lifecycle-ops.ts header comments dropped the 'no dispatcher / not gated
    by WL_SDK_ENABLED' framing now that the dispatcher and flag are gone.
  - wasteland.worker.ts auth-probe and browse-direct routes are now described
    in their own terms rather than in libwl-comparative terms.
  - 'direct' parameter on wanted-board ops is documented as accepted for API
    compatibility but silently ignored \u2014 the SDK has no upstream-direct write.

services/wasteland/MONITORING.md rewritten:
  - Removes containerStatus / containerJoin / getWantedBoard /
    refreshWantedBoard from the procedure table.
  - Adds joinWasteland, listMyForkBranches, discardBranch, publishBranch,
    listMyPulls, resolveOwnerRepo.
  - Drops container-specific alert conditions.
  - Notes that the new lifecycle/branch ops are not currently rate-limited
    at the tRPC layer (separate decision if ever needed).

services/wasteland/docs/:
  - wasteland-container-retirement.md DELETED \u2014 retirement is complete; the
    plan and design context live in git history.
  - admin-mode.md reduced from 509 lines (mid-stream design + session log)
    to ~80 lines describing the current architecture (loadSdkContext,
    verifyUpstreamAdmin, etc.).
  - e2e-testing.md updated: Path A reframed as 'production code path via
    SDK' (was 'container'); /debug/.../container/* and /debug/.../wanted
    rows removed; RIG_HANDLE lookup re-pointed at /auth-probe.

services/gastown/src/util/wasteland-client.util.ts: removed the dead
refreshWantedBoard tRPC client method (the procedure was removed in M3.4
and was never actually present on the wasteland router).

packages/wl-sdk/README.md updated to describe the SDK as the production
path rather than scaffolding.

Tests: 86/86 wasteland, 186/186 wl-sdk, web typecheck clean.

* chore(wasteland): remove final stale 'container' references in source

After M3.6's docs sweep, four source-code comments still mentioned the
retired Cloudflare Container or pointed at the deleted retirement doc.
Rewritten to describe the current architecture without referring to
deprecated history:

  services/wasteland/src/wasteland.worker.ts:486 \u2014 debug routes block
  services/wasteland/src/trpc/router.ts:777     \u2014 createUpstream
  services/wasteland/src/trpc/router.ts:828     \u2014 storeCredential
  services/wasteland/src/util/dolthub-api.util.ts:74     \u2014 anon probe
  services/wasteland/src/util/dolthub-api.util.test.ts:6 \u2014 test header

Final acceptance grep:
  rg 'libwl'                services/wasteland/src/  \u2192 zero hits
  rg 'container'            services/wasteland/src/  \u2192 zero hits
  rg '"containers"'       services/wasteland/wrangler.jsonc \u2192 zero hits
  rg '@cloudflare/containers' services/wasteland/package.json \u2192 zero hits

The plan's acceptance criteria 1-4 are now strictly satisfied.

* feat(wasteland): harden DoltHub review workflows

* feat(wasteland+web): stale-fork detection, sync CTA, accept idempotency, browse reconciliation

Picks up from the v3 wl-sdk migration and lands a sweep of correctness
and UX fixes uncovered by end-to-end testing against real DoltHub data
(jrf0110/wl-commons upstream + jfawcett/wl-commons fork).

Key surfaces:

wl-sdk
  - publish: replace prior open/merged/closed PR-search idempotency
    with a tighter branch-HEAD-vs-main-HEAD comparison. Reusing a
    stale merged PR (e.g. the no-diff PR a `wl post` auto-publish
    leaves on the same `wl/<rig>/<id>` branch) shadowed fresh accept
    commits and made the UI report "merged" against the wrong PR.
    Now publish only reuses an open PR for the branch; a no-op is
    only returned when the branch tip already equals main.
  - browse: only flip `entry.source` to `'fork'` when the fork
    branch's `updated_at` is strictly newer than the upstream main
    row's. Fixes the post-accept-merge case where a stale
    `wl/<rig>/<id>` branch on the fork keeps shadowing `completed`
    upstream rows as `in_review`. Fork row stays attached for the
    drawer's branch tab.
  - state: new `readBranchHead` and `assertForkMainCurrent` helpers.
    Mutations now refuse with `code: 'precondition'` and a deep-link
    when fork main is behind upstream main (idempotent already-applied
    branches still short-circuit before the gate).
  - export `readBranchHead` from the package index.

wasteland service
  - getForkCurrency tRPC query: compares fork main HEAD vs upstream
    main HEAD without writing, returns a prefilled DoltHub
    `pulls/new` URL for the manual sync flow (DoltHub's API has no
    programmatic upstream→fork sync — the fork owner lacks write on
    the parent repo and CALL DOLT_FETCH/MERGE is blocked on hosted
    SQL).
  - acceptWantedItem rebuild: cross-fork reads via
    `submitterForkOwner`, threads `submitterPullId`/`completionId`/
    `evidence`/`submitterRigHandle`, all-in-one chain that writes
    adoption DML on admin's branch, merges admin's PR, closes the
    submitter's PR. Output now `{ success, pr_url, pr_id, merged,
    closed_submitter_pr }`.
  - markWantedItemDone now auto-publishes; output gained `pr_url`.
  - Inbox classifier: `dolthub_url` on InboxCardBase, `fork_owner`
    on InboxItem, SQL-trailer commit-message parsing for
    cloud-issued PRs (`Run SQL query: ... -- wl <verb>: <id>`).
    New 9-case inbox-classifier.test.ts.
  - debugErrorResponse surfaces the cause chain so accept/sync
    failures show the underlying DoltHub error in dev probes.
  - new debug endpoints: fork-currency, fork-sync-experiment
    (records the 14-probe rejection of every cross-repo path so
    future readers don't re-run the investigation).

apps/web
  - persistent Sync fork header CTA on both wasteland route trees
    (RepoDashboardHeader and WastelandDashboardHeader). Yellow when
    stale, muted when current; tooltip explains the manual flow and
    deep-links to a prefilled DoltHub pulls/new page using the
    `fromBranchOwner`/`fromBranchRepo`/`fromBranch`/`toBranch` query
    params Next.js exposes server-side.
  - SyncForkButton uses Radix tooltip primitives directly with
    popover tokens for dark-mode contrast (the shared ui/tooltip
    primitive uses bg-primary as a brand-yellow accent for short
    single-line tooltips).
  - Inbox row → drawer with inline AcceptForm for work-submission
    items; drawer EvidenceCard handles both URL and prose evidence
    with extractFirstUrl recovery for "PR submitted: <url>" inputs.
  - DoltHub integration page: drop the dev-only banner.
  - Navigation reorg: remove top-level Wastelands from personal +
    org sidebars; surface a Wastelands section on the personal
    /gastown overview; gate WastelandSettingsSection on
    `!organizationId`.

Tests
  - wl-sdk: 199 passing (added stale-fork browse case; updated
    overlay-with-fresh-fork test to use a strictly-newer
    updated_at; rewrote publish.test.ts to cover head-match no-op,
    open-PR reuse, and create-fresh-PR paths).
  - wasteland: 99 passing (added stale-branch browseViaSdk case;
    updated fork-currency fixtures across all mutation tests; fixed
    pre-existing 4 failures inherited from the M3 commit by
    aligning mocks with the new SDK fanouts).

Files this commit also picks up from the prior session's plan that
were left uncommitted (per SESSION_SUMMARY_2026-05-18.md): owner/repo
URL routing in the inbox card, gastown wasteland nav, M3.6 docs
sweep, accept-upstream submitter-fork fix, mayor `gt_wasteland_done`
URL-only constraint and gastown handler validation.

Verified end-to-end against the real DoltHub data:
  - Stale-fork claim attempt → 412 PRECONDITION_FAILED with deep
    link.
  - Re-running an admin accept after the prior PR merged → 200 with
    no-op pull id (no DoltHub 400).
  - First-time admin accept of jfawcett's `wl done` (PR #21) → fresh
    adoption PR #22 opened, merged, jfawcett's PR closed, upstream
    main has the wanted=completed + completion + stamp.
  - Browse on jfawcett's wasteland: previously-stale `in_review`
    items now correctly show `completed` from upstream after merge,
    independent of whether the local `wl/jfawcett/*` branch was
    discarded.

* chore(wasteland): drop unused WASTELAND_JWT_SECRET binding

The secret hasn't been read by any source under services/wasteland/src
since the v3 wl-sdk migration replaced the legacy JWT auth path with
KILO_AUTH_PUBLIC_KEY (kilo user JWT) and the per-credential DoltHub
OAuth flow gated by WASTELAND_ENCRYPTION_KEY. Removing the dangling
binding keeps wrangler config and the generated Env types honest.

The Secrets Store entry WASTELAND_JWT_SECRET_PROD remains in the store
and can be deleted out-of-band when convenient; this commit only
unbinds it from the worker.

* fix(web): clear pre-existing lint errors blocking pre-push hook

Four oxlint failures had accumulated on the staging branch and were
blocking the push hook:

- apps/web/src/app/(app)/wasteland/by-id/[wastelandId]/settings/SettingsClient.tsx
  unused `Label` import — drop it.
- apps/web/src/app/(app)/wasteland/[owner]/[repo]/settings/SettingsClient.tsx
  same unused `Label` import — drop it.
- apps/web/src/app/api/internal/integrations/dolthub/token/route.ts
  `parsed.data.organizationId!` non-null assertion. The Zod
  `.refine` above guarantees exactly one of `userId`/`organizationId`
  is set, but TS doesn't see through the refinement. Branch on each
  property explicitly so flow-sensitive narrowing supplies a
  non-undefined `id` without the `!`. Adds an unreachable 400
  fallback to keep the function total — no behavioral change for
  any valid request.
- apps/web/src/components/wasteland/drawer/WantedItemPanel.tsx
  `hasPull` declared but unused — drop it. `PullEmptyState` already
  derives the relevant flag from `hasBranch`.

No other behavior changes.

* chore: revert .husky/pre-push and drop wasteland-gastown-poc plan

Both were pulled into the staging-v3 squash by accident:

- .plans/wasteland-gastown-poc.md is a working plan that doesn't
  belong in version control (the .plans/ convention is to gitignore).
- .husky/pre-push gained a CI/container short-circuit that bypassed
  format/lint/typecheck on push. Reverting to origin/main's version
  so push hooks behave consistently with mainline.

* chore: dev-server fixes after main merge

Three small fixes to keep dev servers building/running after pulling
main:

- apps/web/tsconfig.json: add explicit "moduleResolution": "node".
  Without it, the Next.js TS plugin and our shared @kilocode/* path
  aliases stop resolving correctly under newer typescript versions.
  Array reformatting in this file is from Next/VS Code's TS-config
  auto-format and is purely cosmetic.

- package.json: bump packageManager to pnpm@11.1.3 with the integrity
  hash. Matches the version Corepack now installs by default and keeps
  the per-checkout pnpm version pinned.

- services/gastown/scripts/prepare-container.mjs: strip
  `patchedDependencies:` from the generated container pnpm-workspace.yaml
  in addition to `packages:`. Keep `overrides:`, `allowBuilds:`,
  `publicHoistPattern`, and the minimumReleaseAge rules so pnpm 11
  inside the container honours the same policy as the monorepo root.
  Without keeping `overrides:` the container install fails with
  ERR_PNPM_LOCKFILE_CONFIG_MISMATCH; without `allowBuilds:` it fails
  with ERR_PNPM_IGNORED_BUILDS for transitive native-build deps like
  msgpackr-extract in non-interactive mode.

* fix(web): revert apps/web/tsconfig.json changes that broke CI

The previous commit (2928755) introduced two tsconfig regressions:

1. Added "moduleResolution": "node", which TS 5.x rejects with
   error TS5108 ('Option 'moduleResolution=node10' has been removed').
   The legacy 'node' value is an alias for the removed 'node10'; the
   right replacement on a modern TS would be 'bundler' or 'node16',
   but neither is needed here — Next.js's tsconfig defaults work
   without an explicit moduleResolution.

2. Reformatted single-line arrays into multi-line, which oxfmt's
   format:check rejects.

Restoring the file to its post-merge baseline (commit 0f51eff)
keeps both checks happy. The dev server doesn't need the
moduleResolution override.

Verified: pnpm format:check clean, pnpm --filter web typecheck clean.

* chore(web): remove wasteland legacy URL bridge from next.config.mjs

The bridge rewrote `/wasteland/<uuid>/...` to
`/wasteland/by-id/<uuid>/...` to keep pre-M2.2 UUID-keyed URLs
working alongside the new `/wasteland/<owner>/<repo>/...` tree.
Wasteland never shipped to production, so there are no historical
URLs to preserve. The bridge is dead code.

The `apps/web/src/app/(app)/wasteland/by-id/` route tree stays —
the org-scoped wasteland routes
(`/organizations/[id]/wasteland/[wastelandId]/...`) and the new
owner/repo tree share several client components and the
`WastelandPageHeaderContext` from there. Direct
`/wasteland/by-id/<uuid>/...` URLs remain functional; only the
`/wasteland/<uuid>/...` rewrite shortcut is gone.

* chore: revert packageManager bump to pnpm@11.1.2

Commit 2928755 bumped packageManager from pnpm@11.1.2 to 11.1.3
as part of the post-merge dev-server fixes. 11.1.3 was only just
published — pin back to the previously-tested 11.1.2 to avoid
forcing a not-yet-vetted release on every developer and CI run.

* chore(wasteland): Omit wasteland from auto-deploy
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@chrarnoldus chrarnoldus chrarnoldus approved these changes
@lambertjosh lambertjosh Awaiting requested review from lambertjosh

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@chrarnoldus