c8ctl-plugin-nano 1.69.0 → 1.69.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -714,21 +714,30 @@ the job with a decremented retry count. Profiles are stored in the plugin's
714
714
  >
715
715
  > **Recovery scope (what survives a re-activation):**
716
716
  > - **Committed work is durable *only when this activation re-checks-out the exact
717
- > branch the prior run pushed onto*** — a single invariant: `repository.ref` names a
718
- > stable non-base branch **and** `branch.create` names that **same** branch
719
- > (`create === ref`). The clone lands the workspace on `ref` (prior commits present),
720
- > and `provisionRepo`'s honored `git checkout -B <create>` is then a no-op that keeps
721
- > the workspace on it and pushes it back, so the resumed agent can inspect it for the
722
- > **last pushed commit** (`git log` / the open PR for what landed). Every other shape
723
- > is **not** durable and is classified **transcript-only**: a `ref`-only job with no
724
- > `branch.create` (the PR-based review/fix-ci/rebase shape) is committed onto a
725
- > **per-run `nano/agent-work/<base>-<runId>` fallback branch** the next clone of `ref`
726
- > never sees; a `branch.create` that differs from `ref` does `checkout -B <create>`
727
- > off the freshly re-cloned base and never fetches the existing remote `<create>`; and
728
- > a base-like ref/create, a bare-URL / base-only clone, `branch.push=false`, or a
729
- > `repository.sha`-detached checkout likewise recover nothing. For every transcript-only
730
- > run the resume preamble points at the transcript (VERIFY-first) rather than promising
731
- > a branch to check out.
717
+ > branch the prior run pushed onto* — and only when the envelope alone can *prove*
718
+ > that.** One envelope shape qualifies: `repository.ref` names a stable non-base
719
+ > branch **and** `branch.create` names that **same** branch (`create === ref`). The
720
+ > clone lands the workspace on `ref` (prior commits present) and `provisionRepo`'s
721
+ > honored `git checkout -B <create>` is a no-op that keeps it there and pushes it back,
722
+ > so the resumed agent can inspect it for the **last pushed commit** (`git log` / the
723
+ > open PR for what landed). The **ref-only** shape (no `branch.create`, the PR-based
724
+ > review/fix-ci/rebase shape) is deliberately **transcript-only** even though
725
+ > `provisionRepo` often *does* push the checked-out PR head: that decision hinges on
726
+ > `provisionRepo` **resolving the remote default** (a checked-out branch that *is* the
727
+ > default is base-like and gets fallback-branched, and an unresolvable default fails
728
+ > closed), and resume gating runs **before the clone with no network**, so it can never
729
+ > prove a bare `ref` is not the repo's (possibly custom, e.g. `trunk`) default — it
730
+ > fails closed to transcript-only rather than over-claim recovery for a
731
+ > fallback-branched run. Every other shape is likewise **not** durable and classified
732
+ > **transcript-only**: a `branch.create` that differs from `ref` does `checkout -B
733
+ > <create>` off the freshly re-cloned base and never fetches the existing remote
734
+ > `<create>`; and a base-like ref/create (including a conventional `main`/`master`
735
+ > head, or a ref-only job with no configured base), a bare-URL / base-only clone,
736
+ > `branch.push=false`, or a `repository.sha`-detached checkout likewise recover
737
+ > nothing. For every transcript-only run the resume preamble points at the transcript
738
+ > (VERIFY-first) rather than promising a branch to check out. (The **#270 provisioning
739
+ > fix** — a ref-only PR head is pushed to, not diverted onto a per-run fallback — is
740
+ > unaffected; only the resume *prompt wording* is conservative here.)
732
741
  > - **Uncommitted working-tree changes are *not* recovered** by default —
733
742
  > the throwaway workspace does not persist across activations, so any delta the
734
743
  > previous run had not committed is lost and the resumed agent re-derives it. The
package/agent-resume.mjs CHANGED
@@ -901,28 +901,41 @@ export function seedResumeEnvelope(envelope, transcriptText, opts = {}) {
901
901
  // Does this envelope declare a STABLE branch the prior run pushed its commits ONTO that
902
902
  // THIS activation will RE-CHECK-OUT with those commits present, so committed work is
903
903
  // durably recoverable? This is the ONLY case that justifies the recovery preamble's
904
- // "your committed work is on the pushed branch" promise, and it is a SINGLE, exact
905
- // invariant (issue #241): `repository.ref` names a stable non-base branch AND
906
- // `branch.create` names that SAME branch (`create === ref`). Why both, and why equal:
904
+ // "your committed work is on the pushed branch" promise. ONE envelope shape qualifies
905
+ // (issue #241): `repository.ref` names a stable non-base branch AND `branch.create` names
906
+ // that SAME branch (`create === ref`). Why:
907
907
  // - the clone checks out `repository.ref`, so only a stable `ref` lands the workspace
908
908
  // on the branch the prior run pushed (with its commits present);
909
- // - provisionRepo's honored `git checkout -B <create>` then keeps the workspace on
910
- // that branch and pushes it back — but ONLY when `create === ref` is the checkout a
911
- // NO-OP that preserves the prior commits. A `create !== ref` does `checkout -B
912
- // <create>` off the FRESHLY re-cloned `ref`/base HEAD and never fetches an existing
913
- // remote `<create>`, so prior commits on it are ABSENT;
914
- // - a `ref` with NO `branch.create` does NOT recover either: provisionRepo's
915
- // `checkedOut && wantPush` arm cuts a per-run `nano/agent-work/<base>-<runId>`
916
- // FALLBACK branch even for a checked-out PR head (the review/fix-ci/rebase shape,
917
- // which `repoEnvelope` emits with no `branch.create`), so the prior commits land on
918
- // a run-scoped ref that is NOT `ref`, and the next clone of `ref` lacks them.
909
+ // - with `create === ref`, provisionRepo's honored `git checkout -B <create>` is a
910
+ // NO-OP that keeps the workspace on the re-cloned `ref` and pushes it back preserving
911
+ // the prior commits;
912
+ // - a `create !== ref` does `checkout -B <create>` off the FRESHLY re-cloned `ref`/base
913
+ // HEAD and never fetches an existing remote `<create>`, so prior commits on it are
914
+ // ABSENT → non-recoverable;
919
915
  // - a repo-less job, `branch.push === false`, or a `repository.sha` (which DETACHES
920
916
  // HEAD, leaving no symbolic branch to push) is likewise non-recoverable.
921
- // A `ref`/`create` equal to the base commits on the base, which provisionRepo ALSO
917
+ // The REF-ONLY shape (no `branch.create`) is deliberately NON-recoverable here, even
918
+ // though provisionRepo's #270 `checkedOut && wantPush` arm often DOES stay on and push
919
+ // the checked-out non-base PR head. The catch: provisionRepo makes that decision AFTER
920
+ // RESOLVING THE REMOTE DEFAULT — a checked-out branch that IS the remote default is
921
+ // base-like and gets fallback-branched — and it FAILS CLOSED (cuts a fallback) whenever
922
+ // that default cannot be resolved. This module runs BEFORE the clone with NO network, so
923
+ // it can never resolve the remote default and thus can never prove a bare `ref` is not
924
+ // the repo's (possibly CUSTOM, e.g. `trunk`) default. A ref-only envelope
925
+ // `{ref:'trunk', baseRef:'main', branch:{push:true}}` is base-like to provisionRepo (it
926
+ // fallback-branches `trunk`) yet neither `main`/`master` nor `=== baseRef` here, so
927
+ // accepting it would OVER-CLAIM recovery for a run whose commits are actually on a per-run
928
+ // fallback (thread 4117276834). So we MIRROR provisionRepo's fail-closed-on-unresolvable-
929
+ // default stance: reject ref-only, requiring the explicit `create === ref` author-declared
930
+ // push target. (A ref-only #270 job still recovers safely — it falls through to the
931
+ // transcript-only preamble, which is VERIFY-first anyway.)
932
+ // A `ref` equal to the base commits on the base, which provisionRepo ALSO
922
933
  // fallback-branches → non-recoverable. The base is resolved with provisionRepo's
923
934
  // PRECEDENCE (`branch.base` before `repository.baseRef`), and a KNOWN non-blank base is
924
935
  // REQUIRED: with no configured base provisionRepo treats the checked-out `ref` as the
925
- // base and fallback-branches it, so a blank base cannot prove `ref` is non-base.
936
+ // base and fallback-branches it, so a blank base cannot prove `ref` is non-base. A
937
+ // conventional default name (main/master) is likewise treated as base-like (provisionRepo
938
+ // fallback-branches the resolved remote default, which the envelope can't reveal here).
926
939
  // (A push *rejected* at runtime is not knowable here; declared intent is the best signal
927
940
  // available at seed time; the recovery preamble is VERIFY-first so a not-yet-reconciled
928
941
  // branch still degrades safely.)
@@ -934,10 +947,19 @@ function envelopeHasPushedBranch(envelope) {
934
947
  if (isNonBlank(repo.sha)) return false;
935
948
  const ref = isNonBlank(repo.ref) ? String(repo.ref).trim() : '';
936
949
  const create = isNonBlank(branch?.create) ? String(branch.create).trim() : '';
937
- // The clone must re-check-out the exact branch the prior run pushed onto: a stable
938
- // `ref` AND a `branch.create` naming that SAME branch. Anything else (ref-only →
939
- // per-run fallback; create-only / create !== ref → `checkout -B` off base) leaves the
940
- // prior commits on a branch this activation does not check out.
950
+ // The clone must re-check-out the exact branch the prior run pushed onto, and we must be
951
+ // able to prove — from the ENVELOPE ALONE (no network at seed time) — that provisionRepo
952
+ // stayed on it rather than cutting a fallback. Only the explicit `create === ref` shape
953
+ // gives that proof: provisionRepo's honored `checkout -B <create>` is a no-op keeping the
954
+ // workspace on the re-cloned `ref` with its prior commits. Reject:
955
+ // - a blank `ref` (nothing stable to check out), and
956
+ // - the ref-only shape (`create === ''`): provisionRepo's push-onto-checked-out-head
957
+ // decision hinges on a remote-default resolution we cannot reproduce here, so a bare
958
+ // `ref` that is secretly the repo's custom default would over-claim recovery for a
959
+ // fallback-branched run (thread 4117276834) — fail closed, and
960
+ // - a create naming a DIFFERENT branch (`create !== '' && create !== ref`): its
961
+ // `checkout -B <create>` off the freshly re-cloned base HEAD never fetches an existing
962
+ // remote `<create>`, so the prior commits on it are ABSENT → non-recoverable.
941
963
  if (ref === '' || create === '' || create !== ref) return false;
942
964
  // provisionRepo ALSO fallback-branches when `ref`/`create` names the RESOLVED REMOTE
943
965
  // DEFAULT branch (base-like), which is not knowable from the envelope here. Conservatively
package/c8ctl-plugin.js CHANGED
@@ -2671,6 +2671,16 @@ const RESERVED_RESULT_KEYS = new Set([
2671
2671
  // signal for consumers (the nested envelope is host-built and correct, but the
2672
2672
  // flat completion vars must not be spoofable).
2673
2673
  'pushFailed', 'pushError', 'strandedCommits', 'branchMismatch', 'scanError',
2674
+ // `worldMarker` is the host-authored world-restore marker (buildWorldMarker,
2675
+ // nano-workforce #324): shape `{commitSha, effects}`, emitted ONLY on a real push
2676
+ // with a 40-hex head. It is spread into the completion vars AFTER the agent's
2677
+ // sanitized result, but ONLY when the host actually built one — so without
2678
+ // reserving it here an agent-supplied `worldMarker` survives sanitizeResultVars
2679
+ // and, whenever this round produced no host marker (no push, or an abbreviated
2680
+ // head SHA), leaks through UNSHADOWED into the completion. That forges a world
2681
+ // push-checkpoint / points world-restore at an arbitrary SHA, so reserve it
2682
+ // alongside the other host-owned git-result keys (thread 4117276817).
2683
+ 'worldMarker',
2674
2684
  ]);
2675
2685
 
2676
2686
  // Parse `text` as a JSON object, returning it only when it is a plain object.
@@ -4706,6 +4716,15 @@ function githubCloneToken({ provider, authRef, secretResolver, ghAuthToken = ghA
4706
4716
  // Clone repo into <runDir>/workspace and check out / create the working branch.
4707
4717
  // Returns { workspaceDir, gitEnv, startSha, workingBranch, remote }. Throws a
4708
4718
  // ProvisionError (token-redacted) on any git failure so the caller can shed.
4719
+ //
4720
+ // Conventional default-branch names. provisionRepo resolves the remote's ACTUAL default
4721
+ // (origin/HEAD / ls-remote --symref) where it can, but when that resolution fails it
4722
+ // conservatively treats these names as base-like so a checked-out branch that is very
4723
+ // likely the shared base is fallback-branched rather than pushed onto directly. Kept in
4724
+ // lockstep with agent-resume.mjs's CONVENTIONAL_BASE_BRANCHES so the provisioning and
4725
+ // resume sides agree on which no-create push targets are recoverable (#270).
4726
+ const CONVENTIONAL_BASE_BRANCHES = new Set(['main', 'master']);
4727
+
4709
4728
  function provisionRepo({ envelope, token, runDir, runId, timeoutMs = 120_000, logger = null, corr = '', abortSignal = null, _runGit = null }) {
4710
4729
  // Test-only seam mirroring finalizeGit: route every git call through `runGitFn` so a
4711
4730
  // deterministic test can observe the per-call timeouts drawn from the shared
@@ -5148,7 +5167,17 @@ function provisionRepo({ envelope, token, runDir, runId, timeoutMs = 120_000, lo
5148
5167
  // timeout): an indeterminate probe cannot prove the create is not the default, so
5149
5168
  // honoring it would re-open the fail-OPEN this guard exists to close (thread 4477).
5150
5169
  let defaultUnverified = false;
5151
- if (explicitCreate && wantPush && explicitCreate !== effectiveBase) {
5170
+ // Resolve the remote default whenever it can change a push-target decision:
5171
+ // - an explicit branch.create we would otherwise HONOR (push enabled, not the base), OR
5172
+ // - #270: the no-create decision below that would otherwise STAY ON and push the
5173
+ // checked-out branch. A checked-out branch that IS the remote default (the
5174
+ // mismatched shape the reviewer flagged: ref=main + baseRef=develop with no
5175
+ // branch.create, where effectiveBase='develop' so an effectiveBase compare alone
5176
+ // misses that 'main' is the shared default) must be recognised as base-like and
5177
+ // fallback-branched, not pushed onto directly.
5178
+ const resolveDefaultForCreate = explicitCreate && wantPush && explicitCreate !== effectiveBase;
5179
+ const resolveDefaultForCheckedOut = !explicitCreate && wantPush && !!checkedOut && checkedOut !== effectiveBase;
5180
+ if (resolveDefaultForCreate || resolveDefaultForCheckedOut) {
5152
5181
  const dh = runGitFn(['rev-parse', '--abbrev-ref', 'origin/HEAD'], { cwd: workspaceDir, env: gitEnv, timeoutMs: provTimeoutMs() });
5153
5182
  if (dh.status === 0) {
5154
5183
  const def = (dh.stdout || '').trim().replace(/^origin\//, '');
@@ -5161,7 +5190,7 @@ function provisionRepo({ envelope, token, runDir, runId, timeoutMs = 120_000, lo
5161
5190
  if (m && m[1] && !m[1].startsWith('-')) remoteDefaultBranch = m[1];
5162
5191
  }
5163
5192
  }
5164
- if (!remoteDefaultBranch && !configuredBaseRef && !envelope.branch?.base) {
5193
+ if (resolveDefaultForCreate && !remoteDefaultBranch && !configuredBaseRef && !envelope.branch?.base) {
5165
5194
  // The create could still be the unverified default — but only if it already
5166
5195
  // exists remotely. Probe for it; a genuinely-new branch stays honored.
5167
5196
  // `ls-remote` does NOT reliably accept `--end-of-options` on older git (<2.24),
@@ -5217,9 +5246,40 @@ function provisionRepo({ envelope, token, runDir, runId, timeoutMs = 120_000, lo
5217
5246
  if (workingBranch === effectiveBase) log.warn?.(`provisionRepo${cs}: branch.create='${workingBranch}' IS the effective base and push is disabled → any commits land directly on the base branch (not pushed, but this throwaway workspace is reaped)`);
5218
5247
  else log.debug?.(`provisionRepo${cs}: branch.create=${workingBranch} → cut work branch off base '${baseBranchName || '(unknown)'}'`);
5219
5248
  } else if (checkedOut && wantPush) {
5220
- // Either no branch.create, OR an explicit create that NAMES the effective base
5221
- // while pushing — both would otherwise commit on the base, so cut a fallback.
5222
- cutFallbackBranch(checkedOut);
5249
+ // No branch.create (or a create that named the base, routed here): the clone
5250
+ // landed on a symbolic branch. If that branch IS the shared base/default — or the
5251
+ // base/default could NOT be resolved (fail closed, #231/4444) — committing +
5252
+ // pushing there races the base and a non-ff reject strands the work, so cut a
5253
+ // fallback off it. But when the clone landed on a KNOWN NON-base branch it is the
5254
+ // PR head (the review-round / fix-ci / rebase shape: nano-workforce's repoEnvelope
5255
+ // emits repository.ref=<PR head> with NO branch.create). That branch IS the
5256
+ // intended push target — stay on it so `finalizeGit` advances the PR head. Cutting
5257
+ // a fallback here would strand the agent's commit on a throwaway nano/agent-work/*
5258
+ // ref while the PR head never moves, which nano-workforce's convergence loop then
5259
+ // (correctly) flags as a no-advance escalation despite a genuine "pushed" round
5260
+ // (the divergence that stranded nano-coder#26/#28 — c8ctl-plugin-nano#270).
5261
+ const baseKnown = !!(effectiveBase || remoteDefaultBranch);
5262
+ const createNamedBase = !!explicitCreate && createNamesBase(explicitCreate);
5263
+ // The checked-out branch is base-like — cut a fallback rather than push onto it —
5264
+ // when it equals the effective base or the RESOLVED remote default
5265
+ // (`createNamesBase`), OR when it is a conventional default name (main/master):
5266
+ // provisionRepo also fallback-branches the resolved remote default, and the resume
5267
+ // contract (agent-resume.mjs `envelopeHasPushedBranch`) conservatively treats
5268
+ // main/master as base-like, so mirror it here so a mismatched ref=main + baseRef=develop
5269
+ // shape is fallback-branched on BOTH sides.
5270
+ const checkedOutBaseLike = createNamesBase(checkedOut) || CONVENTIONAL_BASE_BRANCHES.has(String(checkedOut).toLowerCase());
5271
+ // Fail closed (#231/4444): we needed the remote default to clear a checked-out branch
5272
+ // that is NOT the effective base, but could not resolve it (a transient network/auth
5273
+ // failure emptied both origin/HEAD and the ls-remote --symref fallback). We cannot
5274
+ // prove the branch is not the shared default, so cut a fallback rather than risk a
5275
+ // silent fast-forward push directly onto it.
5276
+ const defaultUnresolvedForCheckedOut = !remoteDefaultBranch && checkedOut !== effectiveBase;
5277
+ if (baseKnown && !checkedOutBaseLike && !createNamedBase && !defaultUnresolvedForCheckedOut) {
5278
+ workingBranch = checkedOut;
5279
+ log.debug?.(`provisionRepo${cs}: no base-naming branch.create; clone landed on non-base PR head '${checkedOut}' (base '${effectiveBase || remoteDefaultBranch}') → commit + push there so the PR head advances`);
5280
+ } else {
5281
+ cutFallbackBranch(checkedOut);
5282
+ }
5223
5283
  } else if (unbornBranch && wantPush) {
5224
5284
  // Unborn branch (empty remote clone) with push enabled: the agent's FIRST
5225
5285
  // commit belongs on a pushable work branch, not stranded on the unborn default.
@@ -8086,6 +8146,38 @@ function runAgentJob(profile, job, opts = {}) {
8086
8146
 
8087
8147
  // Shape the io.nanobpm.agentResult output envelope. When a repository was
8088
8148
  // provisioned (increment 2a), the `git` block adds branch/commits/push/PR facts.
8149
+ /**
8150
+ * Build the world-restore marker (nano-workforce issue #324 / ADR 0062 Slice 4/5, the WORLD half)
8151
+ * from a finalizeGit result, or `null` when the round pushed nothing durable.
8152
+ *
8153
+ * When a round's work actually LANDED on the remote (`gitResult.pushed`), nano-workforce's
8154
+ * `persist-round` worker records a durable push-checkpoint keyed off the pushed commit SHA so a
8155
+ * REPLACEMENT activation (a fresh worktree after a lease loss) reconstructs the working tree to the
8156
+ * EXACT pushed SHA — inverting this round's `git push` into `git fetch && git checkout <sha>` — and
8157
+ * so its no-advance self-heal has a reachable SHA to reconcile the PR head against. It reads the
8158
+ * reserved top-level `worldMarker` completion variable, shape `{commitSha, effects?}` (see
8159
+ * `workers/persist-round/worker.ts` `worldMarkerOf`). Without this the world store stays empty and
8160
+ * world-restore is dark.
8161
+ *
8162
+ * The marker is emitted ONLY when the push succeeded AND the final head SHA is a well-formed 40-hex
8163
+ * object name — the SAME `isCommitSha` guard the consumer applies, so the emit/consume boundaries
8164
+ * can't drift (an abbreviated SHA or a symbolic ref would fail the exact-tree restore contract).
8165
+ * A single `push` effect carries the pushed SHA as its fence idempotency key (per the contract:
8166
+ * push → commit SHA), so a fence-replay on resume skips an already-landed push.
8167
+ */
8168
+ function buildWorldMarker(gitResult) {
8169
+ if (!gitResult || !gitResult.pushed) return null;
8170
+ const commitSha = typeof gitResult.headSha === 'string' ? gitResult.headSha.trim() : '';
8171
+ if (!/^[0-9a-f]{40}$/i.test(commitSha)) return null;
8172
+ const branch = gitResult.branch ? String(gitResult.branch) : null;
8173
+ return {
8174
+ commitSha,
8175
+ effects: [
8176
+ { kind: 'push', idempotencyKey: commitSha, ...(branch ? { description: `push ${branch}@${commitSha.slice(0, 12)}` } : {}) },
8177
+ ],
8178
+ };
8179
+ }
8180
+
8089
8181
  function buildResultEnvelope(result, { sandbox, image, git, result: agentResult, promptResourceKey } = {}) {
8090
8182
  const status = result.ok ? 'completed' : (result.timedOut ? 'timedOut' : 'failed');
8091
8183
  const env = {
@@ -11172,6 +11264,7 @@ async function workAgent(req, flags, ctx) {
11172
11264
  ...(gitResult
11173
11265
  ? { branch: gitResult.branch, commits: gitResult.commits, pushed: gitResult.pushed, pullRequest: gitResult.pr || null }
11174
11266
  : {}),
11267
+ ...(buildWorldMarker(gitResult) ? { worldMarker: buildWorldMarker(gitResult) } : {}),
11175
11268
  });
11176
11269
  // The engine acknowledged completion: the WIP checkpoint is no longer needed.
11177
11270
  if (discardCheckpointOnAck) await checkpointing.discardAfterAck();
@@ -17188,6 +17281,7 @@ export {
17188
17281
  buildAgentPayload,
17189
17282
  buildAgentStdin,
17190
17283
  buildResultEnvelope,
17284
+ buildWorldMarker,
17191
17285
  parseAgentResultObject,
17192
17286
  readAgentResultFile,
17193
17287
  parseResultFromStdout,
@@ -1,5 +1,5 @@
1
1
  {
2
- "version": "0.0.22",
3
- "commit": "f332d33",
4
- "updated": "2026-09-22T00:36:13Z"
2
+ "version": "0.0.23",
3
+ "commit": "28273b3",
4
+ "updated": "2026-09-26T21:03:43Z"
5
5
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "c8ctl-plugin-nano",
3
- "version": "1.69.0",
3
+ "version": "1.69.2",
4
4
  "type": "module",
5
5
  "description": "c8ctl plugin to start, inspect, and stop a local Nano BPM (nanobpmn) cluster",
6
6
  "main": "c8ctl-plugin.js",
@@ -76,12 +76,12 @@
76
76
  },
77
77
  "optionalDependencies": {
78
78
  "node-pty": "^1.0.0",
79
- "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.69.0",
80
- "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.69.0",
81
- "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.69.0",
82
- "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.69.0",
83
- "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.69.0",
84
- "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.69.0",
85
- "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.69.0"
79
+ "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.69.2",
80
+ "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.69.2",
81
+ "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.69.2",
82
+ "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.69.2",
83
+ "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.69.2",
84
+ "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.69.2",
85
+ "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.69.2"
86
86
  }
87
87
  }