Skip to content

feat(features): write and honor devcontainer-lock.json - #146

Merged
bilby91 merged 1 commit into
mainfrom
feat/feature-lockfile
Nov 4, 2026
Merged

bilby91 merged 1 commit into
mainfrom
feat/feature-lockfile

Conversation

@bilby91

@bilby91 bilby91 commented Nov 4, 2026 •

Copy link
Copy Markdown
Member

Closes #26.

The spec's feature lockfile is implemented. The reference CLI has written it by default since 0.87 (devcontainers/cli#1212). Before this PR, the library neither produced nor read it.

Design decisions

Recorded in design/features.md §8.2.

  1. On by default, like the CLI. Up and Build pin to the lockfile and rewrite it when what resolved differs.
    • UpOptions.Lockfile / BuildOptions.Lockfile select the mode: LockfileDefault, LockfileFrozen, LockfileUpgrade or LockfileDisabled.
    • Embedders that don't want files written into user repos set LockfileDisabled.
    • devcontainer up gains --frozen-lockfile and --no-lockfile.
  2. No store change. DiskStore already returns the two values the lockfile records as Fetched.ResolvedRef: the OCI manifest digest and the HTTPS body sha256.
    • OCI features are fetched as repo@<integrity>, which the digest local-first cache (§8.1) serves offline.
    • HTTPS downloads are checked against integrity.
  3. CLI over spec where they differ.
    • Keys are kept verbatim. The spec says to lowercase them; the CLI doesn't.
    • A .devcontainer.json gets a .devcontainer-lock.json.
    • Output is byte-identical to every lockfile the CLI's own test fixtures were generated with.
    • Lockfiles are compared by content, not bytes, so neither tool rewrites the other's file over formatting.
  4. Features baked into the base image keep their existing entry. They aren't fetched, so dropping their entries would churn the file and always fail frozen mode.
  5. Compose reattach neither reads nor writes the lockfile, and the lockfile is not hashed into the compose inputs. The first Up writes it, so hashing it would recreate every compose project once.

Also fixed

When ConfigPath was empty, Up and Build assumed .devcontainer/ for local features and for the compose working directory. That was wrong for a root .devcontainer.json. A relative ConfigPath combined with local features also failed. Both now use the config path that was actually found, and the unreachable fallbacks are removed.

Known gap

The engine doesn't install features that are reachable only through another feature's dependsOn, so they aren't locked either. The README's dependsOn ✅ row overstates what works today. Follow-up: #147.

Testing

  • Unit: feature/lockfile_test.go covers the format golden, read/write and comparison. lockfile_test.go exercises every mode through Engine.Build with a fake store.
  • Integration: TestLockfile_PublicGHCR runs against ghcr.io.
    • The lockfile records the registry's manifest digest.
    • A frozen rebuild succeeds.
    • A frozen build pinned to an unknown digest fails instead of resolving the tag.
  • Full integration suite: passes, except TestComposeSource_DockerInDocker*. Those fail identically on main in the dev sandbox: the docker-in-docker feature's apt step exits 100.

🤖 Generated with Claude Code

@ghost ghost left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code Review — 68b09cf · BLOCKING

The new lockfile does not consistently enforce the behavior its frozen mode promises: pre-baked OCI features can be used without checking their locked artifact, and the empty-feature fast path bypasses stale-entry removal and frozen comparison.

Finding Anchor
🟠 HIGH Frozen mode accepts changed tags when a feature is already baked into the base image
core/version-compatibility
up.go:1278 ↓
🟠 HIGH Frozen builds trust pre-baked features without verifying the lockfile pin
core/version-compatibility
lockfile.go:84
🟡 MEDIUM Removing the final feature leaves stale lock entries and frozen mode skips validation
core/correctness
lockfile.go:96
🟡 MEDIUM Removing the final feature leaves stale lock entries and frozen mode skips validation
core/correctness
up.go:1347

↓ One finding has no line in this diff to sit on, and is argued in full below.

What I reviewed

Coverage: Reviewed the single commit 68b09cf910f4e5166b0f7ec9b8325cf077567794 (14 changed files) against the core review dimensions plus repository mechanisms R1/R2/R5/R7/R8. Read lockfile handling, feature resolution and baked-feature metadata flow, config path propagation, CLI flags, relevant tests and design documentation. Verified OCI pinning/fetch and HTTPS digest checking in the implementation; the spec's documented transitive dependsOn gap is declared and was not reported. No visual evidence applies. .dap/code-review.yml and root AGENTS.md are absent at the governing/base revisions; repository guidance was read from .dap/review/engineering.md, CONTRIBUTING.md, README.md, and design/features.md. Did not run tests/builds or inspect live backend behavior.

Not anchored in the diff

🟠 HIGH · core/version-compatibility

Frozen mode accepts changed tags when a feature is already baked into the base image

up.go:1306-1307 skips fetch for pre-baked features; feature/dockerfile.go:82-85 skips copying/installing them and lockfile.go:80-84 carries lock entries without verification. The cached base-image bytes are therefore used although frozen mode has not shown they match the lockfile pin.

up.go:1278-1279

Fix — In frozen mode, only skip a baked feature when its exact resolved artifact can be verified against the lock entry; otherwise fetch/build the locked digest or return LockfileMismatchError.

Witness

Up or Build in frozen mode with a feature requested and present in the base image metadata: layerFeatures calls markAlreadyInstalled, then the fetch loop skips the feature at up.go:1306-1307. For an existing lock entry for that ref, featureLock.commit copies the entry unchanged at lockfile.go:80-84; it never checks its integrity against the base image's feature artifact. A base image carrying version 1.5 can satisfy request :1 while lockfile pins an older digest, so frozen mode succeeds and uses the baked feature rather than the locked artifact. The test at lockfile_test.go:251-268 only checks that a matching entry is carried forward; no code checks a mismatch.


BLOCKING — at least one finding is at or above this repository's blocking severity. Reply in a finding's own thread to argue it. On the pull request I answer @dap-code-review-by-crunchloop review, pause and resume.

Comment thread lockfile.go
Comment on lines +90 to +96
if next.Equal(l.existing) {
return nil
}
if l.mode == LockfileFrozen {
return &feature.LockfileMismatchError{Path: l.path, Changed: next.Changed(l.existing)}
}
return feature.WriteLockfile(l.path, next)

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 MEDIUM · core/correctness

Removing the final feature leaves stale lock entries and frozen mode skips validation

The LockfileFrozen caller depends on featureLock.commit to compare current feature entries with the persisted lock; when cfg.Features is empty it is not called, so extra prior entries are silently accepted. Default mode likewise leaves the stale persisted entry for subsequent consumers.

Fix — Run lockfile load/commit for empty feature sets as well (while preserving disabled-mode behavior), so default can remove stale entries and frozen mode can report the extra entry.

Witness

A workspace has an existing lock entry, then its devcontainer.json removes its last feature and calls Build/fresh Up in default or frozen mode. layerFeatures returns at up.go:1284-1285 when len(cfg.Features) == 0, so it never reaches the new lock.commit at up.go:1345-1347: default leaves the removed feature's stale entry in place, while frozen mode succeeds without comparing the lockfile to the empty feature set. Evidence: git show 68b09cf:up.go | nl -ba | sed -n '1284,1287p;1343,1347p' outputs 1284 if len(cfg.Features) == 0 {, 1285 return baseImage, baseMeta, nil, and the separate 1345 if err := lock.commit(cfg.Features); err != nil { block. The early return prevents lockfile cleanup/validation on this reachable final-feature-removal state. design/features.md:371-373 says the lockfile is regenerated from scratch so stale entries drop; lockfile.go:18-22 documents frozen mismatch for features added/removed.

Comment thread up.go
Comment on lines +1345 to +1347
if err := lock.commit(cfg.Features); err != nil {
return "", nil, err
}

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 MEDIUM · core/correctness

Removing the final feature leaves stale lock entries and frozen mode skips validation

LockfileFrozen callers depend on this lock.commit call to compare the current feature set with the persisted lock; when cfg.Features is empty the existing early return prevents this consumer from running, accepting extra old entries. Default mode likewise leaves the stale entry for future consumers.

Fix — Run lockfile load/commit for empty feature sets as well (while preserving disabled-mode behavior), so default can remove stale entries and frozen mode can report the extra entry.

Witness

A workspace has an existing lock entry, then its devcontainer.json removes its last feature and calls Build/fresh Up in default or frozen mode. layerFeatures returns at up.go:1284-1285 when len(cfg.Features) == 0, so it never reaches this newly added lock.commit: default leaves the removed feature's stale entry in place, while frozen mode succeeds without comparing the lockfile to the empty feature set. design/features.md:371-373 says the lockfile is regenerated from scratch so stale entries drop; lockfile.go:18-22 documents frozen mismatch for features added/removed.

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

#146 was merged with this finding open; fixed on main by #153 (keeps the label's recorded artifact and checks baked features against the lockfile; reconciles the lockfile when no features are declared).

Comment thread lockfile.go
Comment on lines +80 to +84
if f.AlreadyInstalled {
if entry, ok := l.existing.Entry(f.Ref); ok {
next.Features[f.Ref] = entry
}
continue

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟠 HIGH · core/version-compatibility

Frozen builds trust pre-baked features without verifying the lockfile pin

feature/dockerfile.go:82-85 consumes AlreadyInstalled to use the base-image artifact without fetching or rebuilding; lockfile.go:80-84 accepts this path without ensuring the frozen lock pins that artifact.

Fix — In frozen mode, require an entry for every requested non-local feature and verify that a pre-baked feature's exact resolved artifact matches that entry. Preserve the resolved ref in parsed metadata or fetch/build the locked digest when the comparison cannot be made.

Witness

For a requested OCI feature already present in the base image's devcontainer.metadata, layerFeatures marks it AlreadyInstalled; the fetch loop skips it (up.go:1306-1307). This new branch merely copies an existing lock entry, if any, without comparing it to the base image; if the lockfile has no entry for that feature, it omits it entirely and frozen mode accepts the lockfile as matching. A stale digest is similarly copied unchanged. Code read: feature.ParseMetadataLabel (feature/metadata.go:199-220) drops the metadata ResolvedRef when converting to FeatureMetadata; markAlreadyInstalled (up.go:408-435) matches only feature ID/version, and feature/dockerfile.go:82-85 skips fetching/installing the baked feature. The added baked-feature test (lockfile_test.go:251-268) only uses an existing lock entry and doesn't test an absent or mismatching pin.

Copy link
Copy Markdown
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

#146 was merged with this finding open; fixed on main by #153 (keeps the label's recorded artifact and checks baked features against the lockfile; reconciles the lockfile when no features are declared).

The spec's feature lockfile was neither produced nor read (#26). Up and
Build now pin every OCI and HTTPS feature to its lockfile entry and
write devcontainer-lock.json beside devcontainer.json when what
resolved differs, as the reference CLI does by default since 0.87.

- DiskStore already returns the two values the lockfile records as
  Fetched.ResolvedRef (OCI manifest digest, HTTPS body sha256), so no
  store change: OCI features are fetched as repo@<integrity>, which
  the digest local-first cache serves offline; HTTPS downloads are
  checked against integrity (*feature.FeatureIntegrityError).
- UpOptions.Lockfile / BuildOptions.Lockfile: LockfileDefault,
  LockfileFrozen (*feature.LockfileMismatchError when missing, before
  any fetch, or out of date; never writes), LockfileUpgrade,
  LockfileDisabled. devcontainer up gains --frozen-lockfile and
  --no-lockfile.
- CLI over spec where they differ: keys verbatim, .devcontainer-lock.json
  beside a .devcontainer.json. Output is byte-identical to the CLI's
  generated fixtures; files are compared by content, not bytes.
- Features baked into the base image keep their existing entry.
  Compose reattach does not consult the lockfile, and it is not hashed
  into the compose inputs (the first Up writes it, so hashing it would
  recreate every compose project once).
- Up and Build fix the discovered config path before resolving. They
  previously assumed .devcontainer/ for local features and the compose
  working directory, which was wrong for a root .devcontainer.json;
  a relative ConfigPath with local features also failed.

Closes #26.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@ghost ghost left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code Review — 45c0015 · BLOCKING

No new findings were added; the branch’s existing version-compatibility and correctness findings remain reproducible at the reviewed SHA.

Finding Anchor
🟠 HIGH Frozen mode accepts changed tags when a feature is already baked into the base image
core/version-compatibility
up.go:1278 ↓
🟠 HIGH Frozen builds trust pre-baked features without verifying the lockfile pin
core/version-compatibility
lockfile.go:84
🟡 MEDIUM Removing the final feature leaves stale lock entries and frozen mode skips validation
core/correctness
lockfile.go:96
🟡 MEDIUM Removing the final feature leaves stale lock entries and frozen mode skips validation
core/correctness
up.go:1347

↓ One finding has no line in this diff to sit on, and is argued in full below.

What I reviewed

Coverage: Reviewed 45c0015c262fb870cef8107c4a3e7c31d581b7a8 (one commit, 14 files), focusing on lockfile read/pin/commit behavior, the pre-baked-feature path, config-path handling, and the CLI mode flags. Checked the repository’s R1–R8 guidance in .dap/review/engineering.md at directives base 8f740f1dc0f7c3b7d07e8f2583f45f3b473b220f; .dap/code-review.yml and AGENTS.md are absent there. Reviewed correctness, version compatibility, interface contract, reference-CLI divergence, and test coverage; the normal pin, integrity-check, and lockfile-mode paths are supported by the implementation and added tests. Did not execute tests or the system under review, and did not independently exercise the real runtime integration paths.

Not anchored in the diff

🟠 HIGH · core/version-compatibility

Frozen mode accepts changed tags when a feature is already baked into the base image

up.go:1306-1307 skips fetch for pre-baked features; feature/dockerfile.go:82-85 skips copying/installing them and lockfile.go:80-84 carries lock entries without verification. The cached base-image bytes are therefore used although frozen mode has not shown they match the lockfile pin.

up.go:1278-1279

Fix — In frozen mode, only skip a baked feature when its exact resolved artifact can be verified against the lock entry; otherwise fetch/build the locked digest or return LockfileMismatchError.

Witness

Up or Build in frozen mode with a feature requested and present in the base image metadata: layerFeatures calls markAlreadyInstalled, then the fetch loop skips the feature at up.go:1306-1307. For an existing lock entry for that ref, featureLock.commit copies the entry unchanged at lockfile.go:80-84; it never checks its integrity against the base image's feature artifact. A base image carrying version 1.5 can satisfy request :1 while lockfile pins an older digest, so frozen mode succeeds and uses the baked feature rather than the locked artifact. The test at lockfile_test.go:251-268 only checks that a matching entry is carried forward; no code checks a mismatch.


BLOCKING — at least one finding is at or above this repository's blocking severity. Reply in a finding's own thread to argue it. On the pull request I answer @dap-code-review-by-crunchloop review, pause and resume.

@bilby91
bilby91 merged commit 864709a into main Nov 4, 2026
10 checks passed
@bilby91
bilby91 deleted the feat/feature-lockfile branch November 4, 2026 17:39
bilby91 added a commit that referenced this pull request Nov 4, 2026
…igs (#153)

* fix(features): enforce lockfile pins on baked features and empty configs

Two findings from the review of #146:

- A feature the base image's label satisfied was skipped and its
  existing lock entry copied, so frozen mode accepted a base image
  built from another artifact, or one the lockfile had no entry for.
  The label already records each feature's resolvedRef, but
  ParseMetadataLabel dropped it (and so did carrying base entries into
  a rebuilt label). Keep it on FeatureMetadata, read the lockfile
  before matching the label, and accept a baked feature only when its
  artifact is the pinned one or, with no pin, a recorded one, which is
  then locked. Anything else is fetched at its pin and installed.
  LockfileDisabled keeps the label-only match.
- layerFeatures returned before the lockfile when no features were
  declared, so removing the last feature left its entry behind and
  frozen mode accepted it. Reconcile an existing lockfile then too:
  default and upgrade empty it, frozen reports the stale entries.
  Without a lockfile nothing is created, as with the reference CLI.

The pre-baked hot path is unchanged for images this library built,
whose labels have recorded resolvedRef since v0.1.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(features): re-resolve baked features in lockfile upgrade mode

acceptsBaked found no pin in LockfileUpgrade (pin ignores the lockfile
there) and so accepted any recorded baked artifact, which commit then
locked: an upgrade could replace a newer pin with the older artifact
the base image carries (DAP review finding 3902 on #153). Upgrade mode
now accepts no baked feature, so each reference is resolved afresh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bilby91 <2201079+bilby91@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
bilby91 added a commit that referenced this pull request Nov 5, 2026
* fix(docker): pre-pull the Dockerfile syntax frontend image (#150)

* fix(docker): pre-pull the Dockerfile syntax frontend image

BuildImage builds through ImageBuild with no BuildKit session, and
BuildKit before v0.31 (Docker Engine before 29.6) refuses registry
access without one, even for anonymous public pulls: a bearer
challenge with no session fails with "no active sessions". FROM
images were already pre-pulled through the classic pull API for this
reason; a `# syntax=` frontend was not, so any user Dockerfile naming
one failed before parsing (#148).

Pre-pull the frontend too: the BUILDKIT_SYNTAX build arg, else the
syntax parser directive, read as BuildKit's parser.DetectSyntax reads
it (leading directive lines only, # or // comments, after an optional
BOM and shebang; the image is the value's first word).

Verified against a Docker 29.5.0 daemon (containerd image store):
the new integration test fails there with the reported error without
this change and passes with it. Docker 29.6+ resolves anonymously
without a session, so it passes there either way.

Fixes #148.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(docker): pre-pull a frontend named by a JSON syntax document

BuildKit's parser.DetectSyntax falls back, after the # and // directive
forms, to a JSON object with a string "syntax" member, the input of
custom frontends that take JSON, and uses the whole value as the
frontend image. syntaxFrontend left that form out, so its frontend was
not pre-pulled and hit the session-less resolution failure on engines
before 29.6 (DAP review finding 3891 on #150).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bilby91 <2201079+bilby91@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* fix(features): enforce lockfile pins on baked features and empty configs (#153)

* fix(features): enforce lockfile pins on baked features and empty configs

Two findings from the review of #146:

- A feature the base image's label satisfied was skipped and its
  existing lock entry copied, so frozen mode accepted a base image
  built from another artifact, or one the lockfile had no entry for.
  The label already records each feature's resolvedRef, but
  ParseMetadataLabel dropped it (and so did carrying base entries into
  a rebuilt label). Keep it on FeatureMetadata, read the lockfile
  before matching the label, and accept a baked feature only when its
  artifact is the pinned one or, with no pin, a recorded one, which is
  then locked. Anything else is fetched at its pin and installed.
  LockfileDisabled keeps the label-only match.
- layerFeatures returned before the lockfile when no features were
  declared, so removing the last feature left its entry behind and
  frozen mode accepted it. Reconcile an existing lockfile then too:
  default and upgrade empty it, frozen reports the stale entries.
  Without a lockfile nothing is created, as with the reference CLI.

The pre-baked hot path is unchanged for images this library built,
whose labels have recorded resolvedRef since v0.1.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(features): re-resolve baked features in lockfile upgrade mode

acceptsBaked found no pin in LockfileUpgrade (pin ignores the lockfile
there) and so accepted any recorded baked artifact, which commit then
locked: an upgrade could replace a newer pin with the older artifact
the base image carries (DAP review finding 3902 on #153). Upgrade mode
now accepts no baked feature, so each reference is resolved afresh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bilby91 <2201079+bilby91@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

* feat(features): install features reachable only through dependsOn

dependsOn only ordered features that devcontainer.json declared anyway:
an undeclared dependency was silently skipped, so a feature relying on
one installed without it (#147). The spec makes dependsOn a hard
dependency, installed recursively with the options it names.

- layerFeatures' fetch loop appends each fetched feature's dependsOn
  requirements and fetches them in turn: lockfile pinning, option
  validation and defaults apply as for declared features, and they are
  locked under their dependsOn key as the reference CLI does.
- Spec equality decides duplicates: same content (digest) and same
  options once defaults apply. A repeat of a key with the same options
  is skipped before fetching, which also ends cycles; the same content
  under another reference is dropped after. One feature with different
  options is installed once per set, and topoSort maps an id to all
  its entries, pointing dependsOn edges at the one with the requested
  options.
- A dependency the base image's label satisfies is not fetched or
  installed again: bakedFeature, factored from markAlreadyInstalled,
  includes the lockfile's check of the artifact the label records.
  Its own dependencies are still followed, as are a declared baked
  feature's, since an image built before this change lacks them.
  Labels now record each feature's dependsOn ({} when none); for a
  label written before that, the baked feature's metadata is fetched
  at its recorded artifact to find them.
- A dependency dropped as a duplicate under another reference is still
  locked under its own key.
- The compose inputs hash also covers a local dependency's content,
  which the declaring feature's content does not; projects without one
  hash as before.
- OCI references are lowercased before parsing, as the CLI's getRef
  does: published dependsOn keys such as ghcr.io/codspace/dependson/A
  failed to parse.

The integration test builds the CLI's own lockfile-dependson fixture in
frozen mode against its expected lockfile.

Closes #147.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(features): record the baked match's option gap for dependencies

The DAP review of #151 (finding 3903) notes a baked dependency is reused
whatever options it was requested with. The pre-baked match has never
compared options, for declared features either; record the limitation
in §5.1 and track the fix to the match itself in #154.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(features): lock an unpinned baked feature with its dependsOn

The DAP review of #153 (finding 3904) noted a baked feature accepted
without a pin was locked from its label entry, which then had no
dependsOn. This change fills it in before commit; pin it with a test
for a label that records dependsOn and for an older one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(features): confine local dependsOn paths

The DAP review of #151 (findings 3912, 3919, 3917) showed a fetched
feature's dependsOn could name a local path, absolute or escaping with
.., which layerFeatures resolved against devcontainer.json's directory,
copied into the build context and ran: published metadata choosing a
host directory to execute. The compose inputs hash also missed such a
dependency, since it follows local dependencies from declared local
features only.

A local dependsOn key is now followed only from a local feature, and
only as a relative path that resolves, symlinks included, inside the
directory of devcontainer.json, as the reference CLI requires of local
features; anything else fails Up and Build. With remote features unable
to reach local dependencies, the compose hash's traversal covers every
one. Declared local features keep their existing resolution.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(features): never take a dependsOn dependency from the base image

The DAP review of #151 (finding 3913) showed a dependency the base
image's label listed was reused whatever options its dependsOn entry
asked for: the pre-baked match compares id and version only, and those
options are the feature author's, which no user config could route
through that match before. Dependencies are now always fetched and
installed; a declared baked feature still is not reinstalled, and its
dependencies are installed. Until #154 adds option matching, a
pre-baked image whose features have dependencies reinstalls them on
every build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bilby91 <2201079+bilby91@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

devcontainer-lock.json: feature lockfile not produced or honored

1 participant