nono-cli

Version	Released
`0.80.0` minor	Oct 13, 2026
`0.79.0` minor	Sep 30, 2026
`0.78.0` minor	Sep 16, 2026
`0.77.0` minor	Sep 11, 2026
`0.76.0` minor	Sep 09, 2026
`0.75.0` minor	Sep 01, 2026
`0.74.0` minor	Aug 19, 2026
`0.73.0` minor	Aug 10, 2026
`0.72.0` minor	Aug 07, 2026
`0.71.0` minor	Jul 31, 2026
`0.70.0` minor	Jul 29, 2026
`0.69.0` minor	Jul 20, 2026
`0.68.0` minor	Jul 14, 2026
`0.67.1` patch	Jul 06, 2026
`0.67.0` minor	Jul 06, 2026
`0.66.0` minor	Jun 29, 2026
`0.65.1` minor	Jun 23, 2026
`0.64.1` patch	Jun 20, 2026
`0.64.0` minor	Jun 18, 2026
`0.63.0` minor	Jun 15, 2026
`0.62.0` minor	Jun 07, 2026
`0.61.2` patch 1 CVE	Jun 05, 2026
`0.61.1` patch 1 CVE	Jun 02, 2026
`0.61.0` minor 1 CVE	Jun 02, 2026
`0.60.0` minor 1 CVE	Jun 01, 2026
`0.59.0` minor 1 CVE	May 27, 2026
`0.58.0` minor 1 CVE	May 26, 2026
`0.57.0` minor 1 CVE	May 20, 2026
`0.56.0` minor 1 CVE	May 18, 2026
`0.55.0` minor 1 CVE	May 17, 2026
`0.54.0` minor 2 CVEs	May 13, 2026
`0.53.0` minor 2 CVEs	May 11, 2026
`0.52.2` patch 2 CVEs	May 11, 2026
`0.52.1` patch 2 CVEs	May 11, 2026
`0.52.0` minor 2 CVEs	May 10, 2026
`0.51.0` minor 2 CVEs	May 09, 2026
`0.50.1` patch 2 CVEs	May 08, 2026
`0.50.0` minor 2 CVEs	May 08, 2026
`0.49.0` minor 2 CVEs	May 07, 2026
`0.48.0` minor 2 CVEs	May 07, 2026
`0.47.1` patch 2 CVEs	May 06, 2026
`0.47.0` minor 2 CVEs	May 05, 2026
`0.46.0` minor 2 CVEs	May 04, 2026
`0.45.0` minor 2 CVEs	Apr 30, 2026
`0.44.0` minor 2 CVEs	Apr 29, 2026
`0.44.0-alpha.1` pre 2 CVEs	Apr 29, 2026
`0.43.1` patch 2 CVEs	Apr 29, 2026
`0.43.0` minor 2 CVEs	Apr 28, 2026
`0.42.0` minor 2 CVEs	Apr 25, 2026
`0.41.0` minor 2 CVEs	Apr 24, 2026

0.80.0 minor

Oct 13, 2026

0.79.0 minor

Sep 30, 2026

0.78.0 minor

Sep 16, 2026

0.77.0 minor

Sep 11, 2026

0.76.0 minor

Sep 09, 2026

0.75.0 minor

Sep 01, 2026

0.74.0 minor

Aug 19, 2026

0.73.0 minor

Aug 10, 2026

0.72.0 minor

Aug 07, 2026

0.71.0 minor

Jul 31, 2026

0.70.0 minor

Jul 29, 2026

0.69.0 minor

Jul 20, 2026

0.68.0 minor

Jul 14, 2026

0.67.1 patch

Jul 06, 2026

0.67.0 minor

Jul 06, 2026

0.66.0 minor

Jun 29, 2026

0.65.1 minor

Jun 23, 2026

0.64.1 patch

Jun 20, 2026

0.64.0 minor

Jun 18, 2026

0.63.0 minor

Jun 15, 2026

0.62.0 minor

Jun 07, 2026

0.61.2 patch

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

Jun 05, 2026

0.61.1 patch

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

Jun 02, 2026

0.61.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

Jun 02, 2026

0.60.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

Jun 01, 2026

0.59.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

May 27, 2026

0.58.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

May 26, 2026

0.57.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

May 20, 2026

0.56.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

May 18, 2026

0.55.0 minor

1 CVE

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

May 17, 2026

0.54.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 13, 2026

0.53.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 11, 2026

0.52.2 patch

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 11, 2026

0.52.1 patch

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 11, 2026

0.52.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 10, 2026

0.51.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 09, 2026

0.50.1 patch

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 08, 2026

0.50.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 08, 2026

0.49.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 07, 2026

0.48.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 07, 2026

0.47.1 patch

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 06, 2026

0.47.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 05, 2026

0.46.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

May 04, 2026

0.45.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 30, 2026

0.44.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 29, 2026

0.44.0-alpha.1 pre

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 29, 2026

0.43.1 patch

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 29, 2026

0.43.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 28, 2026

0.42.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 25, 2026

0.41.0 minor

2 CVEs

GHSA-hc4m-q9jh-xw4j Jul 28, 2026

nono-cli'scregistry pack verification can fail open when provenance metadata is absent

6.6 / 10

Medium

Local Low Low Required Unchanged High High None

Summary

Registry-installed nono packs are expected to be verified from local provenance metadata before they are used. Two files are relevant:

~/.config/nono/packages/lockfile.json
~/.config/nono/packages/<namespace>/<pack>/.nono-trust.bundle

Testing shows that nono fails closed when a pack has a trust bundle but no lockfile entry. However, if the trust bundle is also absent, the same pack can load successfully. Deleting security metadata should not make a pack easier to run.

Affected behavior

Observed with always-further/claude:

Delete ~/.config/nono/packages/lockfile.json.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Delete ~/.config/nono/packages/always-further/claude/.nono-trust.bundle.

Result: the profile loads successfully.

Restore .nono-trust.bundle while the lockfile is still absent.

Result:

nono: Package verification failed for always-further/claude: pack 'always-further/claude' has a trust bundle but no lockfile entry - reinstall with: nono pull always-further/claude --force

Impact

If both the lockfile entry and trust bundle are absent, nono may accept an installed registry pack without artifact hash verification or provenance verification.

This is especially important for pack-provided session hooks, because session hooks execute on the host outside the sandbox. A pack that contributes host-executed code should not run unless nono can verify that the code is a locked and trusted pack artifact.

Root cause

verify_profile_packs treats the lockfile entry as optional. Existing code fails when a trust bundle exists without a matching lockfile entry, but when the trust bundle is absent too, there is no equivalent hard failure.

That creates a fail-open state:

lockfile entry missing
trust bundle missing
pack directory still present
profile can load

Recommended fix

For any registry pack selected for execution, require both:

A matching lockfile entry in ~/.config/nono/packages/lockfile.json.
A present and valid .nono-trust.bundle in the installed pack directory.

If either is missing, fail closed with a reinstall instruction, for example:

reinstall with: nono pull <namespace>/<pack> --force

This keeps verification monotonic: removing provenance metadata cannot downgrade a verification failure into a successful launch.

Fixed in


          0.61.3

References

Updated Jul 28, 2026 · Source: OSV.dev

CVE-2026-47128 GHSA-27vp-2mmc-vmh3 May 28, 2026

nono: Sandbox escape on Linux via D-Bus: `systemd-run --user`

6.1 / 10

Medium

Local Low Low None Unchanged None High Low

Summary

The nono Landlock/seccomp policies allow access to local Unix domain sockets (concrete and abstract). This allows an easy sandbox escape by talking to the per-user systemd dbus socket.

Threat scenario: Running Aider, Claude Code, OpenCode or similar tools with "allow bash" policy so that it can invoke arbitrary host tools like make, gcc, etc. to write code.

Reproducer

Here, instead of running a tool like opencode or claude one can just invoke systemd-run, but this is something an agent could be tricked into doing:

$ cd ~/src/myproject
$ nono run -s --allow-cwd --profile claude-code -- \
      systemd-run --user -q --wait --collect \
      /bin/sh -c "echo oops > ~/Documents/escaped.txt"
$ cat /var/home/test/Documents/escaped.txt
oops
$

Impact

Complete sandbox escape. The unsandboxed sibling process can write anywhere the user can write, spawn arbitrary processes with network access, etc.

Maintainer Context

This issue allows a process running inside the sandbox to escape confinement by interacting with local user-scoped IPC mechanisms and regain the authority already held by the invoking user or service account.

The issue impacts the sandbox’s confinement and blast-radius reduction guarantees for agents and sandboxed tooling. However, exploitation does not provide privilege escalation, cross-user access, or host compromise beyond the permissions already available to the launcher outside the sandbox.

This issue affects the CLI policy layer and bundled sandbox profiles. The underlying core library nono does not ship with policy definitions or agent-facing confinement profiles by default, nor do the language SDKs.

This is considered a serious issue because an AI agent or untrusted command stream operating within the sandbox could abuse the bypass to perform unauthorized or destructive actions using the delegated authority of the launching user.

The root cause was incomplete mediation of local Unix domain socket access within affected sandbox policies. Support for restricting this behavior has since been added and the fix is available in the repository pending release.

CVSS rationale: exploitation requires execution within a locally launched sandboxed process using the authority already delegated by the invoking user or service account (AV:L/PR:L). The issue allows reliable bypass of sandbox confinement and policy guarantees, resulting in high integrity impact (I:H) and limited availability impact (A:L) through destructive actions within the launcher’s existing permissions. However, the issue does not provide privilege escalation, cross-user access, or a change in security scope (S:U).

Fixed in


          0.55.0

References

Updated May 28, 2026 · Source: OSV.dev

Apr 24, 2026

Activity

Reach

Details