arcane-os 0.89.0 → 0.90.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.90.0
+
+- Add optional `remoteBase` to repository workspaces, Git text snapshots and
+  explicit pull/push targets. Applications can declare a remote as a local
+  filesystem locator and capture its native absolute Git argument before
+  asynchronous work or queueing, independently of later directory changes.
+- Preserve original remote, ref and base text in public outcomes. Omission
+  retains ordinary Git remote names, URLs, SCP-like addresses and remote-helper
+  strings without guessed parsing; existing identity, cancellation, complete
+  diagnostics and configured-operation behavior remain unchanged.
+- Reuse the retained compatible Windows host, Whisper and ONNX runtime assets
+  on this numeric release. No native implementation change is included.
+
 ## 0.89.0
 
 - Add explicitly selected clone-local author name/email before the first

package/docs/reference/core-native-packaging.md

@@ -401,6 +401,11 @@ or service. Availability of a particular engine belongs to the selected
 local-AI installer and service; a generic ONNX runtime is not a speech model.
 
 Selected `onnx` bundles its complete managed `onnxruntime-node` dependency tree.
+For the SDK-selected Windows x64 ONNX `1.30.0` distribution, that tree includes
+the corrected native libraries and its runtime record retains
+`nativeDistributionRevision: '1.30.0-directml-reshape-1'`. See
+[ONNX runtime preparation](local-ai.md#development) for selection,
+release-asset acquisition and existing-installation behavior.
 Its `modulePath` resolves against the artifact root just as a server runtime's
 `executable` does. Library/module records need no executable. The generated Core
 service exposes retained worker sessions through `onnx.load/run/unload/status`;

package/docs/reference/core-repositories.md

@@ -47,7 +47,7 @@ const status = await repository.status({signal});
 await repository.close();
 ```
 
-`createRepositoryWorkspace({name,directory,dataRoot,remote,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run}={})`
+`createRepositoryWorkspace({name,directory,dataRoot,remote,remoteBase,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run}={})`
 returns `{directory,open,status,configuration,pull,push,write,close,drain,dispose}`. The `directory`
 property is the absolute selected working path.
 
@@ -63,6 +63,10 @@ property is the absolute selected working path.
   `branch`, when supplied, is passed unchanged to Git's `clone --branch` option;
   otherwise Git selects the remote's default branch. Existing checkouts keep
   their own branch, remote, tracked files, untracked files and local changes.
+- Supplying `remoteBase` explicitly declares this initial-clone `remote` to be
+  a local filesystem locator. Its native absolute command argument is captured
+  during construction. Omission leaves Git's original string interpretation
+  unchanged. See [relative local repository locators](#relative-local-repository-locators).
 - Optional `longPaths` is a boolean for newly cloned Windows checkouts. Explicit
   `true` or `false` supplies `clone --config core.longpaths=<value>`, so Git
   writes that choice to the new repository before its first checkout. Omission
@@ -173,13 +177,13 @@ commands for an attached local branch, or three otherwise. Results are not a
 transaction with later work or external Git activity. The app owns any decision
 that the current checkout corresponds to its selected repository and branch.
 
-The optional `target:{remote,ref}` on `pull`, `push` and `write` selects that
-operation's Git destination. Both fields are nonempty strings representable by
+The optional `target:{remote,ref,remoteBase?}` on `pull`, `push` and `write` selects
+that operation's Git destination. `remote` and `ref` are nonempty strings representable by
 the native process transport. The SDK captures their exact strings when the
 call is accepted; later edits to the target object or UI selection cannot
 redirect queued or active work. Git owns ref parsing, URL interpretation,
 credentials, hooks and remote outcomes. This target is independent of the
-factory's `remote`/`branch`, which remain initial-clone inputs only.
+factory's `remote`/`remoteBase`/`branch`, which remain initial-clone inputs only.
 
 ```javascript
 const observed = await repository.configuration({signal});
@@ -208,6 +212,54 @@ observe, refresh, write and publish. See Git's [pull](https://git-scm.com/docs/g
 [push](https://git-scm.com/docs/git-push) and [configuration](https://git-scm.com/docs/git-config)
 contracts.
 
+### Relative local repository locators
+
+`remoteBase` is an explicit local-path choice, not a hint for a URL parser.
+With it, the SDK derives the Git remote argument using the host's native
+`path.resolve(remoteBase, remote)`. A relative base, including `''` for the
+current directory, is resolved once when a workspace/snapshot owner is
+constructed or a targeted operation is accepted. Later working-directory or
+options-object changes cannot redirect that accepted operation. Base text
+must be representable as a native filesystem path; invalid non-string, NUL or
+unpaired-surrogate input reports `TypeError` without changing the supplied text.
+
+Use the same selected absolute base for owners created at different times:
+
+```javascript
+import {createGitTextSnapshot} from 'arcane-os';
+import {createRepositoryWorkspace} from 'arcane-os/core/repositories';
+
+const remote = connection.locator; // Keep the original catalog string.
+const remoteBase = connection.localBaseDirectory; // App-selected absolute base.
+const repository = createRepositoryWorkspace({name: connection.name, remote, remoteBase});
+const snapshot = createGitTextSnapshot({
+    cacheDirectory: connection.cacheDirectory,
+    remote, remoteBase, ref: connection.ref, selectPath: applicationSelectPath
+});
+const target = {remote, remoteBase, ref: connection.ref};
+await repository.write({files: selectedFiles, message, target, signal});
+// This reader wants the newly published selection, so refresh after the write.
+await snapshot.refresh({signal});
+```
+
+The original locator and ref remain unchanged. Public targeted results and
+writer failure outcomes also retain the explicitly supplied original
+`remoteBase`, including its relative spelling or empty string; the derived
+absolute argument stays with the Git invocation. No catalog/configuration
+rewrite, directory change or extra Git command is introduced. The existing
+Git clone may save its supplied remote argument as its ordinary origin setting.
+
+Omit `remoteBase` for configured names such as `origin`, URLs, SCP-like addresses,
+remote-helper syntax, or any other string Git should interpret normally. With
+an explicit base, even `origin` means the local path under that base. The SDK
+does not infer intent from slashes, colons or platform path spelling. Factory
+`remoteBase` affects only cloning; an individual pull/push/write uses only its
+own `target.remoteBase`. Omitting `target` retains configured Git behavior.
+The public `repositoryPull` and `repositoryPush` functions accept the same
+target field and capture it before their first asynchronous status operation.
+Actual filesystem, Git, credential and remote failures retain their existing
+complete diagnostics; this option adds no fallback, retry or unborn-state rule.
+
 ## Git identity configuration
 
 ```javascript
@@ -438,8 +490,8 @@ Successful completion returns:
 
 Each output record retains complete stdout/stderr. `code` and the process
 termination `signal` are included when a completed process result is available.
-When supplied, `target:{remote,ref}` is included in the result or failure outcome
-with the original accepted strings.
+When supplied, `target:{remote,ref,remoteBase?}` is included in the result or
+failure outcome with the original accepted strings.
 An in-progress write also records its current `path` on a failure outcome.
 `writtenPaths` records successful filesystem writes in input order; `written`
 becomes true only after every requested write succeeds. The other booleans

package/docs/reference/git-text-snapshot.md

@@ -33,12 +33,27 @@ policy stable for the lifetime of its snapshot owner.
 
 ## API and lifecycle
 
-`createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,gitIdentity,onEvent,run})`
+`createGitTextSnapshot({cacheDirectory,remote,remoteBase,ref,selectPath,gitIdentity,onEvent,run})`
 returns `{refresh,close,drain,dispose}`. `run` defaults to the SDK's existing
 `runProcess`; applications normally omit it. It is the same process adapter
 contract, not a second process supervisor. `onEvent` is the ordinary SDK event
 callback and follows its asynchronous completion/error contract.
 
+Optional `remoteBase` explicitly selects `remote` as a local filesystem locator.
+The owner derives its native absolute Git argument once during construction
+using `path.resolve(remoteBase, remote)`, independently of the cache location
+and later working-directory changes. A relative base is captured against the
+construction-time working directory; `''` explicitly selects that directory.
+The caller's original locator and options remain unchanged. Without this field,
+every existing Git remote string keeps its ordinary meaning; the SDK does not
+guess whether a name, URL, colon or slash describes a local path.
+
+Use the same app-selected absolute base for snapshot, workspace clone and each
+explicit pull/push/write target. Factory clone inputs do not become operation
+targets. See [relative local repository locators](core-repositories.md#relative-local-repository-locators)
+for the shared contract, original target outcomes and example. This option adds
+no I/O, remote probe, configuration change, retry or empty-remote success path.
+
 Optional `gitIdentity:{name?,email?,username?}` uses the shared
 [Git identity configuration contract](core-repositories.md#git-identity-configuration).
 Supplied strings are captured during construction and accompany every Git

package/docs/reference/inventory/package-api.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.88.1",
+  "sdkVersion": "0.89.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
@@ -311,14 +311,14 @@
       "name": "createRepositoryWorkspace",
       "displayName": "createRepositoryWorkspace()",
       "kind": "function",
-      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run=runProcess}={})",
+      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,remoteBase,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run=runProcess}={})",
       "entrypoints": ["arcane-os/core/repositories"],
       "primaryImport": "arcane-os/core/repositories",
       "group": "Native repository workspaces",
       "summary": "Owns one selected native working checkout with ArcaneData/Repos defaults and existing Git/process lifecycle.",
       "availability": "Node with Git on Windows, Linux and macOS; Android requires host process adaptation",
       "protocol": "Git working repository and SDK process adapter",
-      "normalization": "Returns directory, open, status, configuration, pull, push, write and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are preserved. Optional longPaths captures a boolean: explicit Windows true/false supplies clone-local core.longpaths before the first checkout, persisting only in the new repository under ordinary Git configuration precedence. Omission preserves configuration; existing repositories and non-Windows clone commands remain unchanged. No global setting or migration. configuration observes the existing root, symbolic HEAD, origin URL/pushURL arrays and branch remote/merge/upstream URL arrays without clone/init/fetch, preserving unset, empty and repeated values. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work. pull/push/write accept a captured target {remote,ref} for current-branch fast-forward pull or non-force current-HEAD selected-ref push; omission retains ordinary configured behavior. write snapshots exact text and paths, stages/commits only literal owned paths and preserves unrelated staged files and Git filters. Complete outputs and causal failures retain confirmed local/committed/pushed and uncertain outcomes plus the supplied target. Optional gitIdentity captures name/email/username for child Git operations only; omitted fields remain inherited and identity selection writes no config file. Optional cloneIdentity captures exact name/email strings and persists only supplied fields through clone --config before the first checkout on every supported platform. Empty strings are explicit; omitted or undefined fields preserve inherited/template configuration. Existing checkouts are never reconfigured. Unrepresentable process arguments fail honestly without transforming them. This option changes no global configuration or credentials and does not identify an authenticated account; command-local gitIdentity remains independent."
+      "normalization": "Returns directory, open, status, configuration, pull, push, write and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are preserved. Optional factory remoteBase explicitly selects the initial-clone remote as a local filesystem locator and captures path.resolve(remoteBase, remote) once at construction. A relative base, including an empty string, uses the construction-time working directory. Only the Git argument is derived; the caller's original locator remains unchanged. Omission preserves every Git remote name, URL, SCP-like address and remote-helper string without guessed parsing. Optional longPaths captures a boolean: explicit Windows true/false supplies clone-local core.longpaths before the first checkout, persisting only in the new repository under ordinary Git configuration precedence. Omission preserves configuration; existing repositories and non-Windows clone commands remain unchanged. No global setting or migration. configuration observes the existing root, symbolic HEAD, origin URL/pushURL arrays and branch remote/merge/upstream URL arrays without clone/init/fetch, preserving unset, empty and repeated values. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work. pull/push/write accept a captured target {remote,ref,remoteBase?} for current-branch fast-forward pull or non-force current-HEAD selected-ref push; omission retains ordinary configured behavior. An operation's own remoteBase declares local-path intent and captures its native absolute argument once at acceptance, before queueing; factory remote/remoteBase/branch remain independent clone inputs. Targeted pull/push results and writer results/failure outcomes retain the original remote, ref and supplied remoteBase, including relative or empty base text. Unrepresentable base text reports TypeError without transformation. write snapshots exact text and paths, stages/commits only literal owned paths and preserves unrelated staged files and Git filters. Complete outputs and causal failures retain confirmed local/committed/pushed and uncertain outcomes plus the supplied target. Optional gitIdentity captures name/email/username for child Git operations only; omitted fields remain inherited and identity selection writes no config file. Optional cloneIdentity captures exact name/email strings and persists only supplied fields through clone --config before the first checkout on every supported platform. Empty strings are explicit; omitted or undefined fields preserve inherited/template configuration. Existing checkouts are never reconfigured. Unrepresentable process arguments fail honestly without transforming them. This option changes no global configuration or credentials and does not identify an authenticated account; command-local gitIdentity remains independent."
     },
     {
       "id": "core-repositories:readGitIdentity",
@@ -493,14 +493,14 @@
       "name": "createGitTextSnapshot",
       "displayName": "createGitTextSnapshot()",
       "kind": "function",
-      "signature": "createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})",
+      "signature": "createGitTextSnapshot({cacheDirectory,remote,remoteBase,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})",
       "entrypoints": ["arcane-os"],
       "primaryImport": "arcane-os",
       "group": "Workspace, doctor, repository, and server",
       "summary": "Reads complete selected text from one fetched revision using a dedicated bare Git object cache and batched retrieval.",
       "availability": "Node with Git; Android requires a host supplying Git/process capability",
       "protocol": "Git tree and batched blob transport through the shared process owner",
-      "normalization": "Returns {refresh,close,drain,dispose}; refresh yields {revision,files:[{path,content}]}, shares concurrent work, reuses unchanged revisions, preserves exact UTF-8 text, isolates caller cancellation and drains accepted work. Optional gitIdentity captures name/email/username for child Git commands including bare init and fetch, without changing config files, payloads or shared acquisition lifetime. See git-text-snapshot.md."
+      "normalization": "Returns {refresh,close,drain,dispose}; refresh yields {revision,files:[{path,content}]}, shares concurrent work, reuses unchanged revisions, preserves exact UTF-8 text, isolates caller cancellation and drains accepted work. Optional remoteBase explicitly selects remote as a local filesystem locator and derives only its Git fetch argument through path.resolve(remoteBase, remote), once at construction independently of the cache location and later working-directory changes. A relative base, including an empty string, uses the construction-time working directory; original locator/options remain unchanged. Omission preserves every Git remote name, URL, SCP-like address and remote-helper string without guessed parsing. Unrepresentable base text reports TypeError without transformation; existing Git failures remain errors. Optional gitIdentity captures name/email/username for child Git commands including bare init and fetch, without changing config files, payloads or shared acquisition lifetime. See git-text-snapshot.md."
     },
     {
       "id": "diarization:createDiarization",
@@ -609,10 +609,10 @@
       "entrypoints": ["arcane-os/local-ai"],
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
-      "summary": "Reuses selected managed native runtimes or installs complete official llama.cpp/Ollama/image distributions, ONNX npm runtime trees or NeMo libraries.",
-      "availability": "Node; upstream platform and architecture assets determine runtime availability",
-      "protocol": "Official upstream release archives and selected ONNX/Koffi npm runtime installations",
-      "normalization": "Returns absolute runtime records, including image library/binding/variant/model metadata; shares matching installs, preserves libraries, reports failures without changing global PATH or services and prepares no model files"
+      "summary": "Reuses selected managed native runtimes or installs complete llama.cpp/Ollama/image distributions, ONNX npm runtime trees with selected SDK native libraries, or NeMo libraries.",
+      "availability": "Node; selected distribution platform and architecture assets determine runtime availability",
+      "protocol": "Upstream release archives and selected ONNX/Koffi npm installations; corrected Windows x64 ONNX native libraries from the installed SDK numeric release",
+      "normalization": "Returns absolute runtime records, including image library/binding/variant/model metadata; Windows x64 ONNX with no explicit URL and omitted version or 1.30.0 adds nativeDistributionRevision 1.30.0-directml-reshape-1, reuses that revision or prepares a fresh installation while preserving older trees; explicit URLs and other ONNX versions/platforms retain their upstream package path; shares matching installs, preserves libraries, reports failures without changing global PATH or services and prepares no model files"
     },
     {
       "id": "local-ai:bundleLocalAIRuntimes",
@@ -624,9 +624,9 @@
       "primaryImport": "arcane-os/local-ai",
       "group": "Core local AI",
       "summary": "Copies selected complete runtime distributions into a fresh native artifact staging root.",
-      "availability": "Node; supports bundling published upstream platform assets independently of the build host",
+      "availability": "Node; supports bundling selected published platform assets independently of the build host",
       "protocol": "Artifact-relative runtime/local-ai layout",
-      "normalization": "Returns {runtimes,files} with artifact-relative runtime/variant paths and complete inventory; image URL descriptors remain for post-launch preparation and external model working paths report portability incompatibility"
+      "normalization": "Returns {runtimes,files} with artifact-relative runtime/variant paths and complete inventory; corrected Windows x64 ONNX retains nativeDistributionRevision and complete native libraries while modulePath becomes artifact-relative; image URL descriptors remain for post-launch preparation and external model working paths report portability incompatibility"
     },
     {
       "id": "root:WS",
@@ -2269,7 +2269,7 @@
       "summary": "Runs one fast-forward-only pull into the selected clean worktree, optionally from a captured remote/ref target.",
       "availability": "Node; network-assisted Git",
       "protocol": "Node ESM",
-      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+      "normalization": "Optional target {remote,ref,remoteBase?} is captured before the first asynchronous status operation. A supplied remoteBase declares local-path intent and derives only the Git remote argument using path.resolve(remoteBase, remote), once at acceptance; relative and empty bases use that working directory. Omitted remoteBase preserves Git remote names, URLs, SCP-like addresses and remote-helper strings unchanged. Targeted results retain original remote/ref/supplied remoteBase text and complete stdout/stderr alongside the existing pull result. Unrepresentable base text reports TypeError without transformation. Omitted target preserves configured pull behavior and result shape; clean-worktree, fast-forward-only, cancellation and actual Git error behavior remain unchanged."
     },
     {
       "id": "root:repositoryPush",
@@ -2285,7 +2285,7 @@
       "summary": "Pushes the attached branch through ordinary configured Git or an explicit captured current-HEAD destination without force.",
       "availability": "Node; network-assisted Git",
       "protocol": "Node ESM",
-      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+      "normalization": "Optional target {remote,ref,remoteBase?} is captured before the first asynchronous status operation. A supplied remoteBase declares local-path intent and derives only the Git remote argument using path.resolve(remoteBase, remote), once at acceptance; relative and empty bases use that working directory. Omitted remoteBase preserves Git remote names, URLs, SCP-like addresses and remote-helper strings unchanged. Targeted results retain original remote/ref/supplied remoteBase text and complete stdout/stderr alongside the existing push result. Unrepresentable base text reports TypeError without transformation. Omitted target preserves configured push behavior and result shape; attached-branch, non-force current-HEAD publication, cancellation and actual Git error behavior remain unchanged."
     },
     {
       "id": "root:repositoryStatus",

package/docs/reference/local-ai.md

@@ -138,10 +138,23 @@ Zstandard archives use the supported Node runtime's decompressor.
 
 Selected ONNX preparation installs `onnxruntime-node@1.30.0` by default into a
 managed npm prefix, retaining its complete published runtime dependency tree.
-It uses the upstream CPU installation option to skip supplementary GPU downloads.
+The npm installation skips supplementary upstream GPU downloads. On Windows
+x64, an omitted version or explicit `1.30.0`, with no explicit `url`, also
+selects the SDK's corrected native distribution, revision
+`1.30.0-directml-reshape-1`. The installer downloads
+`arcane-onnx-runtime-windows-x64.tar.gz` from the installed `arcane-os` package's
+numeric GitHub release and extracts its native libraries into the new
+installation. Its URL is
+`https://github.com/TheWizardNexus/arcane-os-sdk/releases/download/<sdk-version>/arcane-onnx-runtime-windows-x64.tar.gz`.
+The same-version npm JavaScript and binding remain in place. Explicit URLs,
+other ONNX versions and other platform/architecture selections retain their
+upstream package path. For the corrected selection, an existing installation
+without the matching `nativeDistributionRevision` is left intact and a fresh
+installation is prepared; running installations keep their original trees.
 Node/npm must be available while preparing that runtime; a native app consumes
 the bundled tree without installing it again. Applications that omit ONNX do
-not install its package.
+not install its package. Runtime preparation alone establishes no model or
+device execution result.
 
 For the optional development browser connection, load the bootstrap after the
 managed import map and before creating a Core-backed provider:
@@ -722,7 +735,7 @@ not execution evidence on each platform.
 
 ## Native bundling
 
-The SDK portable native build includes selected official runtime trees under
+The SDK portable native build includes complete selected runtime trees under
 `runtime/local-ai/<runtime-id>`. Runtime records in the artifact are relative
 to the artifact root and resolve on the destination machine. The generated
 Core entry composes the local AI service only when the application selects it.
@@ -732,13 +745,16 @@ Model files remain application-selected native resources.
 `arcane-os/local-ai`. Both accept `{runtimes,directory,platform,architecture,
 signal,onEvent}`; bundling also requires `outputRoot`. Platform names follow
 Node: `win32`, `linux`, `darwin`, and supported Android distributions.
-Architectures are `x64` or `arm64`. Availability depends on the upstream
-runtime's published platform assets; Ollama has no official Android runtime
+Architectures are `x64` or `arm64`. Availability depends on the selected
+distribution's published platform assets; Ollama has no official Android runtime
 archive in this installer.
 
 Ensure returns absolute `{id,version,platform,architecture,root}` records.
 Server runtimes also include `executable`; ONNX includes `modulePath` pointing
-to its public package entry. Image records include `libraryPath`,
+to its public package entry. The corrected Windows x64 ONNX selection also
+includes `nativeDistributionRevision: '1.30.0-directml-reshape-1'`; bundling
+retains that metadata with the complete native libraries. Image records include
+`libraryPath`,
 `bindingModulePath`, requested `backend`, installed `variants` and selected
 `models` metadata. Variant records carry backend, runtime root and library path.
 Bundle returns `{runtimes,files}`,

package/docs/reference/sdk-api.md

@@ -3831,12 +3831,21 @@ async repositoryPull({ workspaceRoot=process.cwd(), target, signal, onEvent, run
 
 Import it from `arcane-os`. The signature above states whether settlement is synchronous or promise-based. The overview and owning group define result authority, side effects, callbacks, events, cancellation, and lifecycle.
 
-Optional `target:{remote,ref}` captures exact nonempty native-representable
-strings before any wait and selects `git pull --ff-only -- <remote> <ref>:`.
+Optional `target:{remote,ref,remoteBase?}` captures the exact nonempty
+native-representable `remote` and `ref` strings before any wait and selects
+`git pull --ff-only -- <remote> <ref>:`.
 The current clean branch receives a fast-forward-only integration; the SDK
 never switches branches, resets or changes configuration. Without a target,
 the existing configured pull and result remain unchanged. Targeted results
 add `target`, complete `stdout` and `stderr` to the existing pull result.
+
+Supplying `target.remoteBase` explicitly selects a local filesystem locator:
+only the Git remote argument becomes `path.resolve(remoteBase, remote)`, captured
+once at acceptance before status work. Relative bases, including `''`, use the
+working directory at that moment. The returned target retains the original
+`remote`, `ref` and supplied base text. Omission preserves Git remote names,
+URLs, SCP-like addresses and remote-helper strings without guessed parsing.
+Unrepresentable base text reports `TypeError` without transformation.
 See [checkout configuration and selected targets](core-repositories.md#existing-checkout-configuration-and-selected-targets).
 
 ### Availability and normalization
@@ -3877,20 +3886,29 @@ detached HEAD, then, without `target`, runs plain `git push`; the repository's c
 configured upstream/remote, Git credentials, hooks, and server policy remain
 authoritative. Unlike `repositoryPull()`, this function does **not** require a
 clean worktree. It does not create a commit or choose an application destination.
-Optional `target:{remote,ref}` captures the original nonempty
-native-representable strings before any wait and runs
+Optional `target:{remote,ref,remoteBase?}` captures the original nonempty
+native-representable `remote` and `ref` strings before any wait and runs
 `git push --no-follow-tags -- <remote> HEAD:<ref>`. This publishes current HEAD
 to the caller-selected ref without force or implicit configured tag following.
 It changes no branch or Git configuration; credentials, URL interpretation,
 hooks and remote rejection remain Git-owned.
 
+Supplying `target.remoteBase` explicitly selects a local filesystem locator:
+only the Git remote argument becomes `path.resolve(remoteBase, remote)`, captured
+once at acceptance before status work. Relative bases, including `''`, use the
+working directory at that moment. Later directory or target-object changes do
+not redirect accepted work. Omission preserves Git remote names, URLs, SCP-like
+addresses and remote-helper strings without guessed parsing. Unrepresentable
+base text reports `TypeError` without transformation.
+
 The promise resolves to
 `{action:'push', repositoryRoot, branch, output}`. `output` is trimmed stdout,
 or trimmed stderr when stdout is empty. A missing Git executable, failed status
 probe, rejected/nonzero push, cancellation, or event-callback failure rejects
 with the normalized process error. Cancellation stops the local process tree;
 it cannot prove that a remote accepted no objects before the interruption.
-Targeted results also contain the captured `target` and complete
+Targeted results also contain the captured `target`, retaining original
+`remote`, `ref` and any supplied `remoteBase`, and complete
 `stdout`/`stderr`; omitting the target preserves the existing result shape.
 See [checkout configuration and selected targets](core-repositories.md#existing-checkout-configuration-and-selected-targets).
 
@@ -5367,7 +5385,7 @@ a dedicated bare Git cache. It does not create or alter a working checkout.
 ### Signature, lifecycle, and result
 
 ```text
-createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})
+createGitTextSnapshot({cacheDirectory,remote,remoteBase,ref,selectPath,gitIdentity,onEvent,run=runProcess}={})
 ```
 
 Import from `arcane-os`. The application owns the cache location, remote, ref,
@@ -5379,6 +5397,16 @@ await accepted refresh/process cleanup. Errors remain observable instead of
 returning stale or partial success. See [Git text snapshots](git-text-snapshot.md)
 for complete inputs, text semantics, errors, events and Core service composition.
 
+Optional `remoteBase` explicitly selects `remote` as a local filesystem locator.
+Only its Git fetch argument is derived using `path.resolve(remoteBase, remote)`,
+once at construction, independently of the cache location and later changes to
+the working directory. Relative bases, including `''`, use the construction-time
+working directory. Original locator/options remain unchanged. Omission preserves
+Git remote names, URLs, SCP-like addresses and remote-helper strings without
+guessed parsing. Unrepresentable base text reports `TypeError` without
+transformation; actual Git failures retain their existing error behavior.
+See [relative local repository locators](core-repositories.md#relative-local-repository-locators).
+
 Optional `gitIdentity:{name?,email?,username?}` captures a child-process-only
 selection for init/fetch and subsequent Git commands, preserving shared refresh
 cancellation and complete content. See [Git identity configuration](core-repositories.md#git-identity-configuration)
@@ -8348,7 +8376,7 @@ explicit existing path. The application owns the remote, branch and Core API.
 ### Signature and result
 
 ```text
-createRepositoryWorkspace({name,directory,dataRoot,remote,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run=runProcess}={})
+createRepositoryWorkspace({name,directory,dataRoot,remote,remoteBase,branch,longPaths,cloneIdentity,gitIdentity,onEvent,run=runProcess}={})
 ```
 
 Returns `{directory,open,status,configuration,pull,push,write,close,drain,dispose}`. Construction does
@@ -8359,6 +8387,16 @@ work and preserves the checkout. No CLI cwd, launch state, preference, snapshot
 cache or existing user-data location changes. See the [complete inputs, results,
 errors and lifecycle](core-repositories.md#one-connected-working-checkout).
 
+Optional factory `remoteBase` explicitly selects the initial-clone `remote` as
+a local filesystem locator. Only its Git argument is derived through the host's
+native `path.resolve(remoteBase, remote)`, once at construction. Relative bases,
+including `''`, use the construction-time working directory. The caller's
+original locator remains unchanged; Git clone may save the derived argument as
+its ordinary origin setting. Omission preserves Git remote names, URLs, SCP-like
+addresses and remote-helper strings without guessed parsing. Unrepresentable
+base text reports `TypeError` without transformation.
+See [relative local repository locators](core-repositories.md#relative-local-repository-locators).
+
 Optional `longPaths` captures a boolean for new Windows clones. Explicit true
 or false supplies clone-local `core.longpaths` before the first checkout and
 persists it only in the new repository. Omission preserves inherited/template
@@ -8394,11 +8432,15 @@ reports `ARCANE_GIT_CONFIGURATION_NOT_TEXT` with full diagnostics.
 
 `pull({target,signal})`, `push({target,signal})` and
 `write({files:[{path,content}],message,target,signal})` accept optional
-`target:{remote,ref}`, captured as original strings at acceptance. The target
+`target:{remote,ref,remoteBase?}`, captured as original strings at acceptance. The target
 selects a fast-forward-only pull into the current branch or a non-force push
 of current HEAD to the selected ref, without switching branches or changing
-configuration. It is independent of initial-clone `remote`/`branch`; omission
-preserves ordinary configured behavior. See the [complete configuration and
+configuration. An operation's own `remoteBase` declares local-path intent and
+captures the native absolute Git argument once at acceptance, before queueing.
+It is independent of initial-clone `remote`/`remoteBase`/`branch`; omission of
+`target` preserves ordinary configured behavior. Targeted pull/push results and
+writer results/failure outcomes retain original `remote`, `ref` and any supplied
+`remoteBase`, including relative or empty base text. See the [complete configuration and
 target contract](core-repositories.md#existing-checkout-configuration-and-selected-targets).
 
 `write` snapshots the exact selected
@@ -9003,7 +9045,7 @@ import createLocalAIService from 'arcane-os/core/local-ai';
 
 ### Overview
 
-Reuses matching managed runtimes or installs complete selected official
+Reuses matching managed runtimes or installs complete selected
 llama.cpp/Ollama/ONNX/image distributions or NeMo libraries in an explicitly supplied directory.
 
 ### Signature and result
@@ -9016,14 +9058,22 @@ Import it from `arcane-os/local-ai`. Runtime requirements accept IDs or
 `{id,version?,url?}` records. The result is an array of absolute
 `{id,version,platform,architecture,root}` records, with `executable` for servers,
 `modulePath` for ONNX, image `libraryPath`/`bindingModulePath`/`variants`/`models`,
-or NeMo library directories. Image requirements also accept `backend` and
+or NeMo library directories. The SDK-selected Windows x64 ONNX `1.30.0`
+distribution also returns `nativeDistributionRevision: '1.30.0-directml-reshape-1'`.
+With no explicit `url`, an omitted ONNX version or explicit `1.30.0` selects
+the corrected native archive from the installed SDK's numeric release.
+Other ONNX versions, platforms/architectures and explicit URLs retain their
+upstream package path. Reuse requires the selected revision; older installation
+trees remain intact while a fresh installation is prepared. See
+[ONNX runtime preparation](local-ai.md#development).
+Image requirements also accept `backend` and
 `models`; their pinned default runtime, CPU/Metal selection and separate model
 preparation are described in [local image generation](local-image-generation.md).
 Matching concurrent
 installs share their work. Downloads retain runtime libraries and surface
 network/archive failures; cancellation and operation events remain observable.
 Installation changes no global PATH or system service and loads no model.
-Supported assets belong to the selected upstream distribution; see
+Supported assets belong to the selected distribution; see
 [platform and archive requirements](local-ai.md#native-bundling).
 
 ```javascript
@@ -9057,6 +9107,11 @@ contains the complete emitted inventory. Existing runtime destinations are
 preserved and reported as a conflict. Copying settles all started work and
 reports failures/cancellation without executing app services or models.
 
+The corrected Windows x64 ONNX selection retains its
+`nativeDistributionRevision` and complete native libraries. Its `modulePath`
+is relocated with the other runtime paths; bundling introduces no separate
+runtime selection. See [ONNX runtime preparation](local-ai.md#development).
+
 Image records relocate the complete library, binding and variant paths. Model
 URL descriptors retain their original acquisition metadata for preparation
 after launch. Runtime-contained native model paths become artifact-relative;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.89.0",
+  "version": "0.90.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",

package/src/core/repositories.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import Is from 'strong-type';
 import {ArcaneError, throwIfAborted} from '../errors.mjs';
 import {runProcess} from '../process.mjs';
-import {captureRepositoryTarget, repositoryConfiguration, repositoryPull, repositoryPush,
+import {captureRepositoryRemote, captureRepositoryTarget, repositoryConfiguration, pullRepositoryTarget, pushRepositoryTarget,
     repositoryPushArguments, repositoryStatus} from '../repository.mjs';
 import {createGitIdentityRunner} from '../git-identity.mjs';
 
@@ -45,7 +45,7 @@ export function resolveArcaneDataPaths({dataRoot} = {}) {
 
 /** One connected checkout, composed into an application's own Core service. */
 export function createRepositoryWorkspace(
-    {name, directory, dataRoot, remote, branch, longPaths, cloneIdentity = {}, gitIdentity, onEvent, run = runProcess} = {}
+    {name, directory, dataRoot, remote, remoteBase, branch, longPaths, cloneIdentity = {}, gitIdentity, onEvent, run = runProcess} = {}
 ) {
     let selected = directory;
     if (selected === undefined) {
@@ -57,6 +57,7 @@ export function createRepositoryWorkspace(
     }
     requireString(selected, 'directory');
     if (remote !== undefined) requireString(remote, 'remote');
+    const remoteArgument = captureRepositoryRemote(remote, remoteBase);
     if (branch !== undefined) requireString(branch, 'branch');
     if (longPaths !== undefined && !is.boolean(longPaths)) {
         throw new TypeError('longPaths must be a boolean when supplied.');
@@ -119,7 +120,7 @@ export function createRepositoryWorkspace(
         }
         arguments_.push(...cloneConfiguration);
         if (branch !== undefined) arguments_.push('--branch', branch);
-        arguments_.push('--', remote, repositoryDirectory);
+        arguments_.push('--', remoteArgument, repositoryDirectory);
         const result = await prepareRun(
             'git',
             arguments_,
@@ -187,7 +188,7 @@ export function createRepositoryWorkspace(
         return accept(
             async function pullRepository() {
                 await prepare(signal);
-                return repositoryPull({workspaceRoot: repositoryDirectory, target: selectedTarget, signal, onEvent, run: execute});
+                return pullRepositoryTarget(selectedTarget, {workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
             },
             signal
         );
@@ -200,7 +201,7 @@ export function createRepositoryWorkspace(
         return accept(
             async function pushRepository() {
                 await prepare(signal);
-                return repositoryPush({workspaceRoot: repositoryDirectory, target: selectedTarget, signal, onEvent, run: execute});
+                return pushRepositoryTarget(selectedTarget, {workspaceRoot: repositoryDirectory, signal, onEvent, run: execute});
             },
             signal
         );
@@ -246,7 +247,7 @@ export function createRepositoryWorkspace(
             async function writeRepositoryFiles() {
                 const outcome = {
                     directory: repositoryDirectory,
-                    ...(selectedTarget === undefined ? {} : {target: {...selectedTarget}}),
+                    ...(selectedTarget === undefined ? {} : {target: {...selectedTarget.target}}),
                     state: 'local',
                     stage: 'prepare',
                     paths: selectedFiles.map(function selectedPath(file) { return file.path; }),

package/src/git-text-snapshot.mjs

@@ -5,6 +5,7 @@ import {runProcess} from './process.mjs';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from './errors.mjs';
 import {createEventQueue} from './event-queue.mjs';
 import {createGitIdentityRunner} from './git-identity.mjs';
+import {captureRepositoryRemote} from './repository.mjs';
 
 const is = new Is(false);
 const snapshotRef = 'refs/arcane/text-snapshot';
@@ -14,11 +15,12 @@ const snapshotRef = 'refs/arcane/text-snapshot';
  * One application service owns each dedicated cache directory. Construction
  * performs no I/O; refresh coalesces callers and close drains accepted work.
  */
-export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath, gitIdentity, onEvent, run = runProcess} = {}) {
+export function createGitTextSnapshot({cacheDirectory, remote, remoteBase, ref, selectPath, gitIdentity, onEvent, run = runProcess} = {}) {
     for (const [name, value] of Object.entries({cacheDirectory, remote, ref})) {
         if (!is.string(value) || value === '') throw new TypeError(`${name} must be a nonempty string.`);
     }
     if (!is.function(selectPath)) throw new TypeError('selectPath must be a function.');
+    const remoteArgument = captureRepositoryRemote(remote, remoteBase);
     const execute = createGitIdentityRunner(run, gitIdentity);
     const directory = path.resolve(cacheDirectory);
     let prepared = false;
@@ -68,7 +70,7 @@ export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath,
         try {
             await events.send({type: 'git.snapshot.refreshing', message: 'Refreshing the selected repository revision.', data: {ref}});
             await prepare(events);
-            await git(['fetch', '--no-tags', '--no-write-fetch-head', '--', remote, `+${ref}:${snapshotRef}`], {onEvent: events.send});
+            await git(['fetch', '--no-tags', '--no-write-fetch-head', '--', remoteArgument, `+${ref}:${snapshotRef}`], {onEvent: events.send});
             const selected = await git(['rev-parse', '--verify', `${snapshotRef}^{commit}`], {onEvent: events.send});
             const revision = selected.stdout.trim();
             if (retained?.revision === revision) {

package/src/repository.mjs

@@ -56,20 +56,33 @@ export async function readGitText(args, {
     }
 }
 
-/** Capture a caller-selected operation target without changing its strings. */
+/** Derive a Git argument only when the caller explicitly selects a local base. */
+export function captureRepositoryRemote(remote, remoteBase) {
+    if (remoteBase === undefined) return remote;
+    if (!is.string(remoteBase) || !remoteBase.isWellFormed() || remoteBase.includes('\0')) {
+        throw new TypeError('remoteBase must be text representable as a native filesystem path.');
+    }
+    return remote === undefined ? undefined : path.resolve(remoteBase, remote);
+}
+
+/** Keep original selection text separate from the accepted command argument. */
 export function captureRepositoryTarget(target) {
     if (target === undefined) return undefined;
-    const {remote, ref} = target;
+    const {remote, ref, remoteBase} = target;
     for (const [name, value] of Object.entries({remote, ref})) {
         if (!is.string(value) || value === '' || !value.isWellFormed() || value.includes('\0')) {
             throw new TypeError(`target.${name} must be nonempty text representable as a native process argument.`);
         }
     }
-    return {remote, ref};
+    return {
+        target: {remote, ref, ...(remoteBase === undefined ? {} : {remoteBase})},
+        remoteArgument: captureRepositoryRemote(remote, remoteBase)
+    };
 }
 
-export function repositoryPushArguments(target) {
-    return target === undefined ? ['push'] : ['push', '--no-follow-tags', '--', target.remote, `HEAD:${target.ref}`];
+export function repositoryPushArguments(selection) {
+    return selection === undefined ? ['push']
+        : ['push', '--no-follow-tags', '--', selection.remoteArgument, `HEAD:${selection.target.ref}`];
 }
 
 /** Observe an existing workspace without initializing or refreshing it. */
@@ -167,6 +180,12 @@ export async function repositoryPull({
 }={}){
     throwIfAborted(signal);
     const selectedTarget=captureRepositoryTarget(target);
+    return pullRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run});
+}
+
+/** Internal workspace path: its target was already captured before queueing. */
+export async function pullRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run=runProcess}){
+    throwIfAborted(signal);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.clean){
         throw new ArcaneError(
@@ -176,14 +195,14 @@ export async function repositoryPull({
         );
     }
     const args=selectedTarget===undefined?['pull','--ff-only']
-        :['pull','--ff-only','--',selectedTarget.remote,`${selectedTarget.ref}:`];
+        :['pull','--ff-only','--',selectedTarget.remoteArgument,`${selectedTarget.target.ref}:`];
     const result=await git(args,{cwd:workspaceRoot,signal,onEvent,run});
     return {
         action:'pull',
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
         output:result.stdout.trim(),
-        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
+        ...(selectedTarget===undefined?{}:{target:selectedTarget.target,stdout:result.stdout,stderr:result.stderr})
     };
 }
 
@@ -196,6 +215,12 @@ export async function repositoryPush({
 }={}){
     throwIfAborted(signal);
     const selectedTarget=captureRepositoryTarget(target);
+    return pushRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run});
+}
+
+/** Internal workspace path: its target was already captured before queueing. */
+export async function pushRepositoryTarget(selectedTarget,{workspaceRoot,signal,onEvent,run=runProcess}){
+    throwIfAborted(signal);
     const before=await repositoryStatus({workspaceRoot,signal,onEvent,run});
     if(!before.branch){
         throw new ArcaneError(
@@ -209,7 +234,7 @@ export async function repositoryPush({
         repositoryRoot:before.repositoryRoot,
         branch:before.branch,
         output:(result.stdout||result.stderr).trim(),
-        ...(selectedTarget===undefined?{}:{target:selectedTarget,stdout:result.stdout,stderr:result.stderr})
+        ...(selectedTarget===undefined?{}:{target:selectedTarget.target,stdout:result.stdout,stderr:result.stderr})
     };
 }