Independent provider copy changed to an unexpected package i

Error message

Independent provider copy changed to an unexpected package identity

What it means

In copy shape, the script requires the target provider digest after update to be EITHER unchanged (targetProviderAfter === targetProviderBefore, i.e. the historical copy was left alone) OR equal to the current canonical digest (converged). Any third value — changed to something that is neither the original nor the current canonical — is an unexpected identity drift and throws.

Source

Thrown at config/scripts/verify-skill-update-roundtrip.mjs:225

  // Why: this is the exact user-visible rail. A bare update would include
  // unrelated vendors, while this command must leave the control skill alone.
  execSkills(['update', targetName, '--global'])
  await assertCurrentCanonical(targetName)
  const targetProviderAfter = await packageDigestAt(await realpath(targetProvider))
  const targetProviderStat = await lstat(targetProvider)
  if (shape === 'symlink' && !targetProviderStat.isSymbolicLink()) {
    throw new Error(`${targetName} provider alias was replaced with an independent copy`)
  }
  if (shape === 'symlink' && targetProviderAfter !== currentSkill(targetName).packageDigest) {
    throw new Error(`${targetName} provider alias did not converge with the canonical update`)
  }
  if (
    shape === 'copy' &&
    targetProviderAfter !== targetProviderBefore &&
    targetProviderAfter !== currentSkill(targetName).packageDigest
  ) {
    throw new Error('Independent provider copy changed to an unexpected package identity')
  }
  if (shape === 'copy') {
    // Why: hosted 1.5.17 replaces copies with aliases while equivalent local runs
    // retain the copy. Both prove this input topology must remain ineligible.
    const outcome = targetProviderStat.isSymbolicLink()
      ? 'converged to an alias'
      : targetProviderAfter === targetProviderBefore
        ? 'remained a historical copy'
        : 'converged as a copy'
    console.log(`[skill-update-roundtrip] independent copy ${outcome}`)
  }
  if ((await packageDigestAt(controlCanonical)) !== controlBefore) {
    throw new Error('Targeted update changed the non-targeted control skill')
  }
  if ((await packageDigestAt(await realpath(controlProvider))) !== controlProviderBefore) {
    throw new Error('Targeted update changed the non-targeted control provider placement')
  }
  const controlProviderStat = await lstat(controlProvider)

View on GitHub (pinned to 1136503c6a)

Solutions

Confirm autocrlf is set as declared (false avoids drift) and that no external process touches the sandbox.
Diff the provider copy before/after to identify which files changed and why.
Verify currentSkill(targetName).packageDigest matches the actual published package the CLI downloads.
If the CLI wrote the wrong version, file a bug and pin a known-good CLI version.

Defensive patterns

Strategy: validation

Validate before calling

// Before the update, record the baseline digest and the canonical digest:
const targetProviderBefore = await packageDigestAt(targetProvider)
const canonicalDigest = currentSkill(targetName).packageDigest
// The only acceptable post-update values are these two; anything else is drift.
// Surface both in the failure message to speed diagnosis:
if (targetProviderAfter !== targetProviderBefore && targetProviderAfter !== canonicalDigest) {
  throw new Error(`Identity drift: after=${targetProviderAfter} before=${targetProviderBefore} canonical=${canonicalDigest}`)
}

Prevention

Run with --autocrlf=false so line-ending normalization can't fabricate a third digest.
Ensure no other process writes to the sandbox during the run.
Keep the manifest's packageDigest in sync with the published package.

When it happens

Trigger: The update partially overwrote the copy with content from a third version; a file in the copy was mutated by a side effect; the canonical digest changed mid-run; line-ending or mode normalization produced a hash that matches neither baseline.

Common situations: autocrlf mismatch rewriting the copy's line endings so the hash drifts; concurrent process modifying files in the sandbox; CLI regression that writes a different version than currentSkill declares into a copy-topology placement.

Related errors

AI-assisted analysis of stablyai/orca@1136503c6a (2026-08-12). Data as JSON: /api/errors/cf442dbc340b0c2a. Report an issue: GitHub.