arcane-os 0.64.0 → 0.66.0

package/docs/reference/core-repositories.md

@@ -13,7 +13,7 @@ methods. Importing the module and constructing an owner perform no I/O.
 | Host | Default dataRoot | repositoriesRoot |
 |---|---|---|
 | Windows | `%LOCALAPPDATA%/ArcaneData`, or `~/AppData/Local/ArcaneData` when that variable is empty | `<dataRoot>/Repos` |
-| Linux | `$XDG_DATA_HOME/ArcaneData` when XDG_DATA_HOME is absolute, otherwise `~/.local/share/ArcaneData` | `<dataRoot>/Repos` |
+| Linux | `$XDG_DATA_HOME/ArcaneData` when `XDG_DATA_HOME` is absolute, otherwise `~/.local/share/ArcaneData` | `<dataRoot>/Repos` |
 | macOS | `~/Library/Application Support/ArcaneData` | `<dataRoot>/Repos` |
 | Android or another adapted host | Explicit `dataRoot` supplied by the host, such as its app files directory followed by `ArcaneData` | `<dataRoot>/Repos` |
 
@@ -46,8 +46,8 @@ const status = await repository.status({signal});
 await repository.close();
 ```
 
-`createRepositoryWorkspace({name,directory,dataRoot,remote,branch,onEvent,run}={})`
-returns `{directory,open,status,pull,push,close,drain,dispose}`. The `directory`
+`createRepositoryWorkspace({name,directory,dataRoot,remote,branch,gitIdentity,onEvent,run}={})`
+returns `{directory,open,status,pull,push,write,close,drain,dispose}`. The `directory`
 property is the absolute selected working path.
 
 - Omit `directory` to select `<repositoriesRoot>/<name>`. The application supplies
@@ -67,7 +67,8 @@ property is the absolute selected working path.
   authentication remain with Git and the native host. The SDK adds no download,
   credential store, polling, network retry or process supervisor.
 
-All operation methods accept `{signal}={}` and return promises:
+The open/status/pull/push methods accept `{signal}={}` and return promises;
+`write` accepts the complete file/message request described below:
 
 | Method | Result and side effect |
 |---|---|
@@ -75,6 +76,7 @@ All operation methods accept `{signal}={}` and return promises:
 | `status` | Prepares the checkout if needed, then returns the existing `repositoryStatus` result unchanged. |
 | `pull` | Prepares the checkout if needed, then runs the existing clean-checkout, fast-forward-only `repositoryPull` operation unchanged. |
 | `push` | Prepares the checkout if needed, then runs the existing `repositoryPush` operation unchanged, preserving its support for unrelated uncommitted working files. |
+| `write` | Writes exact caller-selected text files, stages and commits only their literal paths, then performs one ordinary non-force push. Returns confirmed operation outcomes; see below. |
 | `close`, `drain`, `dispose` | The same idempotent operation: stop accepting new calls and await accepted work and its process/event cleanup. They retain the repository on disk. |
 
 Opening an existing repository never pulls, switches branches, resets, changes
@@ -85,6 +87,230 @@ A failed or cancelled clone reports the actual failure; any remaining directory
 is retained for application-owned inspection. There is no automatic deletion or
 destructive retry. Filesystem failures and complete Git diagnostics propagate.
 
+## Git identity configuration
+
+```javascript
+import {readGitIdentity, createRepositoryWorkspace} from 'arcane-os/core/repositories';
+
+const defaults = await readGitIdentity({signal});
+const observations = await readGitIdentity({directory: existingRepositoryDirectory, signal});
+const repository = createRepositoryWorkspace({
+    name: 'moon-cheese-dispatches',
+    remote: applicationConnection.remote,
+    gitIdentity: {name: 'Moon Dispatcher', email: 'moon@example.invalid', username: 'moon-account'}
+});
+```
+
+`readGitIdentity({directory,signal,onEvent,run=runProcess}={})` reads only
+`user.name`, `user.email` and `github.user`. It returns:
+
+```text
+{
+    global: {name, email, githubUser},
+    local: {name, email, githubUser} | null,
+    effective: {name, email, githubUser} | null
+}
+```
+
+Every observed field is the complete UTF-8 Git configuration string, including
+an empty string, leading U+FEFF and embedded newlines, or `null` when unset.
+Git can store values outside UTF-8; those produce
+`ARCANE_GIT_IDENTITY_NOT_TEXT` instead of replacement characters. Global and
+local observations select Git's corresponding file scopes and honor configured
+includes. With an existing
+repository `directory`, `effective` reads ordinary Git configuration in that
+repository context, including system, global, local, worktree and command
+configuration where applicable. Equal local and global values remain separate
+observations; the SDK does not infer who wrote or owns a setting. The last
+configured scalar value wins within each observation.
+
+Without `directory`, only global configuration is read and `local`/`effective`
+are `null`. Relative directories resolve from the process working directory.
+Git retains its normal environment and conditional-include context; when no
+directory is supplied, that context is the process working directory. These
+are independent configuration observations, not a transaction or a claim about
+the identity of a prior commit, environment-derived author, or authenticated
+GitHub account. `github.user` is a non-secret configured default, not proof of
+authentication.
+
+One targeted Git command reads each requested scope. Independent observations
+start concurrently and all accepted commands finish their process cleanup
+before the reader settles. `signal` uses the existing process owner; the shared
+SDK event queue serializes `onEvent` delivery with its usual backpressure.
+The reader consumes raw stdout through the existing process contract; stdout
+is parsed as configuration rather than emitted as text events. Process
+lifecycle and stderr events retain their ordinary route. A supplied `run`
+adapter must honor that raw-output contract.
+Git's no-match result produces unset fields; other process,
+configuration, observer and cancellation failures remain complete. A single
+failure retains its original object, code, cause and process `details`; the
+reader adds complete captured stdout as the `rawStdout` Buffer on that error.
+If the error already has that property or cannot accept it, a new error retains
+the original as `cause`, preserves its code, process details and exit code, and
+holds this observation's `rawStdout`. Original causal failures stay on that
+original error; an attachment exception is retained as `attachmentError`.
+An existing `rawStdout` property is never overwritten or invoked to read its value.
+The process result's `stdout` remains `null` in raw mode, and its stderr and
+other diagnostics remain intact. A decoding failure likewise carries its
+original decoding `cause`, complete process `details` and `rawStdout`.
+An observer failure already represented by a process error is not added again;
+genuinely separate failures use `AggregateError.errors`, each retaining its
+own diagnostics.
+No configuration file is written and no credential helper is queried by this
+reader. The application owns any saved non-secret defaults and repository
+overrides through its existing preferences.
+
+Both this workspace factory and
+[`createGitTextSnapshot`](git-text-snapshot.md) accept optional
+`gitIdentity:{name?,email?,username?}`. They capture supplied strings once during
+I/O-free construction. Later edits to that object or a UI selection do not
+change accepted work. Omitted or `undefined` fields preserve ordinary inherited
+behavior; removing an application override means omitting that field on the
+next owner, not changing unmanaged repository configuration. Empty strings are
+passed explicitly to Git. Non-string values, NUL and text that cannot be
+represented by the native process transport report `TypeError` without silently
+rewriting the input.
+
+An application's explicit "global author" choice differs from ordinary Git
+inheritance. Pass the observed global `name` and `email` as selected strings to
+override repository-local author values for those fields. A global `null` means
+that field is unset, not a selected value: passing `null` reports `TypeError`,
+and omitting the field allows normal inheritance, including repository-local
+configuration. The application must describe that partial/inherited choice
+accurately or obtain the missing value before presenting an all-global author
+selection. An empty string is a distinct explicit value that Git may reject.
+Changed application choices apply to future owners; accepted operations retain
+their original selection and may finish without being discarded.
+
+Each supplied name/email becomes command-local `-c user.name=...` or
+`-c user.email=...` and the corresponding child-only `GIT_AUTHOR_*` and
+`GIT_COMMITTER_*` fields. Those selected fields take precedence over inherited
+author/committer settings and environment values; omitted fields, dates and
+unrelated environment remain inherited. Git retains its ordinary commit
+identity formatting and may reject an unusable identity. The SDK changes
+neither `process.env` nor global/local Git files.
+
+`username` supplies only command-local `credential.username`. Git's existing
+credential helper and remote protocol still own actual authentication. A
+URL-embedded username or helper behavior can affect the selected credential;
+this option neither rewrites the remote nor selects an SSH account or proves a
+GitHub login. No account enumeration, secret storage or `gh` dependency is added.
+See Git's [configuration](https://git-scm.com/docs/git-config),
+[author environment](https://git-scm.com/docs/git#_git_commits) and
+[credential username](https://git-scm.com/docs/gitcredentials) contracts.
+
+The selected settings accompany every workspace Git command, including clone,
+pull, commit and push, and every bare-snapshot Git command, including init and
+fetch. Existing arguments, content, output, errors, queue and cancellation
+semantics remain unchanged. Other repository helpers and CLI cwd defaults keep
+their existing behavior.
+
+## Write, commit and push selected text
+
+```javascript
+const result = await repository.write({
+    files: [{path: 'dispatches/moon-cheese.md', content: completeAuthoredText}],
+    message: authoredCommitMessage,
+    signal
+});
+```
+
+`write({files:[{path,content}],message,signal}={})` requires at least one explicit
+file, a nonempty commit message and string content (including an empty string).
+Paths name working files relative to this repository, not its root, outside
+paths or Git-owned `.git` metadata. Strings must be representable as UTF-8;
+native filenames cannot contain NUL. Incompatible input reports a `TypeError`
+before any write, rather than replacing text. Content may contain NUL, BOM,
+CRLF, leading/trailing whitespace and every ordinary Unicode character.
+
+The method copies the selected records and their original strings synchronously
+when called. Later changes to the caller's array, file records or selected UI
+connection cannot alter accepted work. It does not freeze the caller's objects,
+add document labels, normalize line endings, trim content or wrap documents.
+The workspace's originally selected directory remains the operation owner.
+
+After preparing that checkout, it creates needed parent directories and writes
+each complete file using the ordinary native UTF-8 filesystem API. These are
+caller-owned replacements, not an append-only policy or a multi-file atomic
+transaction. Applications choose which paths and content may be replaced.
+Ordinary filesystem behavior, including existing symlinks, remains with the
+native host.
+
+One `git --literal-pathspecs add -- <paths>` stages only those exact names.
+One `git --literal-pathspecs commit --only --cleanup=verbatim --file - -- <paths>`
+commits only those paths, leaving unrelated staged paths staged. The original
+message is streamed unchanged through standard input. One ordinary `git push`
+then uses that repository's existing remote/ref configuration, the optional
+process-local identity selection above, existing credentials and hooks.
+There is no implicit pull, branch switch, forced push,
+hook bypass, automatic retry, rollback or reset. If Git reports no changes to
+commit, that actual failure is returned; the SDK creates no empty commit.
+These are Git's documented [selected-path commit](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---only)
+and [literal pathspec](https://git-scm.com/docs/git#Documentation/git.txt---literal-pathspecs) semantics.
+
+Existing Git attributes, clean filters, EOL settings and hooks continue to apply
+when Git stages/commits content. The filesystem write preserves the original
+text; this API does not claim that repository-configured filters leave Git blob
+text identical. It preserves those settings. A push may also send existing history or other
+refs selected by the repository's ordinary push configuration.
+
+### Result and failure outcomes
+
+Successful completion returns:
+
+```text
+{
+    directory,
+    state: 'pushed',
+    stage: 'complete',
+    paths: [originalSelectedPath, ...],
+    writtenPaths: [confirmedWrittenPath, ...],
+    written: true,
+    staged: true,
+    committed: true,
+    pushed: true,
+    outputs: [{stage: 'prepare'|'stage'|'commit'|'push', stdout, stderr, code?, signal?}, ...]
+}
+```
+
+Each output record retains complete stdout/stderr. `code` and the process
+termination `signal` are included when a completed process result is available.
+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
+record successful Git command completion. **False means success is unconfirmed,
+not that files, the index, HEAD or the remote certainly remained unchanged.**
+
+- `local`: no successful commit or push has been confirmed. Inspect
+  `writtenPaths`, `written`, `staged` and `stage` for actual local progress.
+- `committed`: Git completed the commit; no successful push has been confirmed.
+  Cancellation before push keeps this result rather than claiming delivery.
+- `pushed`: Git reported successful completion of the push. A later observer
+  error retains that confirmed result while still reporting the observer error.
+- `uncertain`: an attempted file write, commit or push did not supply successful
+  completion evidence. Partial files or index changes can remain, and a remote
+  can accept updates before a connection failure hides the acknowledgement.
+  Previously confirmed `writtenPaths`, `committed` or `pushed` evidence remains
+  present. A known pre-spawn failure does not invent a dispatched side effect.
+
+After operation acceptance and execution begins, failures reject with an
+`ArcaneError` whose `cause` is the original complete failure and whose `details`
+is the outcome above. The code/message retain the original failure when
+available, and nested process details remain available through its cause.
+Input errors, a pre-aborted/queued-aborted request or a call after closing reject
+before writer execution and have the existing TypeError/cancellation/closing
+contract. No success is fabricated from an error string or callback.
+
+Cancellation is checked before each subsequent filesystem/Git action. Active
+Git cancellation drains through the existing process owner. Completion is
+recorded before checking cancellation for the next action: an accepted commit
+is retained if push has not begun, and an accepted push is retained if an
+observer subsequently fails. Failed operations leave their actual files and
+index state available for inspection; the application chooses recovery.
+Await or retain the write promise and connect the workspace's terminal drain
+to its Core service lifetime. The application still owns any decision to make
+that Core method service-lifetime rather than request-lifetime work.
+
 ## Ownership, concurrency and shutdown
 
 Calls targeting the same resolved path spelling in one Node process run in
@@ -107,6 +333,8 @@ The caller retains each operation's complete result or failure separately.
 The cold path is one selected connection, one parent-directory creation and one
 Git clone. Opening an existing checkout uses one read-only Git command. A
 prepared owner's status/pull/push use their existing repository operation graph.
+An accepted writer uses one filesystem write per explicitly selected file,
+then one add, one commit and one push, stopping at the first failure.
 There is no scan across applications, connections, models or platforms. Git
 progress, process-starting/completion, heartbeat and cancellation events use
 the existing `onEvent` owner with complete output and backpressure.

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

@@ -33,12 +33,26 @@ policy stable for the lifetime of its snapshot owner.
 
 ## API and lifecycle
 
-`createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,onEvent,run})`
+`createGitTextSnapshot({cacheDirectory,remote,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 `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
+command, including bare initialization and fetch, without changing the remote,
+ref, config files or process environment. Explicit name/email use command-local
+configuration and child-only author/committer fields; omitted fields remain
+inherited. `username` is only Git's credential username hint, not authenticated
+account proof or SSH account selection. Read separate global/local/effective
+configuration through `readGitIdentity` from `arcane-os/core/repositories`;
+the reader also accepts an existing bare cache directory. Applications retain
+saved non-secret choices and per-connection overrides. Identity selection adds
+no process or query to refresh and does not attach a caller's abort to shared
+acquisition.
+
 - `refresh({signal}={})` fetches the selected ref and returns
   `{revision,files:[{path,content}]}`. `revision` is Git's opaque selected commit
   name, not an SDK integrity record. Every file comes from that exact revision,

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

@@ -1,17 +1,143 @@
 {
   "schemaVersion": 1,
-  "sdkVersion": "0.63.0",
+  "sdkVersion": "0.65.0",
   "environment": {
     "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
     "minimumVersion": "22.23.2 for Node entrypoints",
     "moduleSystem": "ESM"
   },
-  "memberCount": 278,
+  "memberCount": 290,
   "runtimeSubpathPatterns": {
     "arcane-os/modules/*": "./runtime/arcane/modules/*",
     "arcane-os/entities/*": "./runtime/arcane/entities/*"
   },
   "members": [
+    {
+      "id": "local-ai-whisper:createWhisperRuntime",
+      "name": "createWhisperRuntime",
+      "displayName": "createWhisperRuntime()",
+      "kind": "function",
+      "signature": "createWhisperRuntime({runtime,prepare,modelId,temporaryDirectory,onEvent}={})",
+      "entrypoints": ["arcane-os/local-ai/whisper"],
+      "primaryImport": "arcane-os/local-ai/whisper",
+      "group": "Core native speech",
+      "summary": "Retains a selected native Whisper helper/model across complete recordings with actual correlated recovery and joined cancellation.",
+      "availability": "Node with prepared matching helper, Whisper libraries, decoder and model; Android needs host process adaptation",
+      "protocol": "Persistent first-party native helper with replaying whisper.state and complete transcription results",
+      "normalization": "Returns current/subscribe/load/transcribe/unload/close; preserves complete original media and text/segment results; one accepted transcription, exact requestId control metadata, eligible auto GPU-to-CPU recovery once, truthful unloaded recovery and terminal errors, joined decoder/helper cleanup"
+    },
+    {
+      "id": "local-ai-whisper:default",
+      "name": "default",
+      "displayName": "createWhisperRuntime default export",
+      "kind": "function",
+      "signature": "default as createWhisperRuntime",
+      "entrypoints": ["arcane-os/local-ai/whisper"],
+      "primaryImport": "arcane-os/local-ai/whisper",
+      "group": "Core native speech",
+      "summary": "Default binding for the same retained native Whisper engine factory.",
+      "availability": "Node with the matching prepared native resources",
+      "protocol": "Native Whisper engine lifecycle",
+      "normalization": "Binding identity equals the named createWhisperRuntime export"
+    },
+    {
+      "id": "local-ai-whisper-build:buildWhisperHelper",
+      "name": "buildWhisperHelper",
+      "displayName": "buildWhisperHelper()",
+      "kind": "function",
+      "signature": "async buildWhisperHelper({runtime,outputRoot,cmake='cmake',generator,cmakeArgs=[],env,signal,onEvent}={})",
+      "entrypoints": ["arcane-os/local-ai/whisper/build"],
+      "primaryImport": "arcane-os/local-ai/whisper/build",
+      "group": "Core native speech",
+      "summary": "Builds and installs the first-party persistent helper against matching prepared Whisper headers and runtime libraries.",
+      "availability": "Node with installed CMake/C++17 toolchain matching the selected platform and architecture",
+      "protocol": "Owned configure/build/install process lifecycle",
+      "normalization": "Returns platform/architecture/root/executable/runtimeDirectory and complete configure/compile/install diagnostics; preserves cancellation and process failures, installs no model or toolchain, performs no inference"
+    },
+    {
+      "id": "local-ai-whisper-openvino-build:buildWhisperOpenVinoRuntime",
+      "name": "buildWhisperOpenVinoRuntime",
+      "displayName": "buildWhisperOpenVinoRuntime()",
+      "kind": "function",
+      "signature": "async buildWhisperOpenVinoRuntime({sourceDirectory,openvinoDirectory,cudaDirectory,outputRoot,cmake='cmake',generator,cmakeArgs=[],env,signal,onEvent}={})",
+      "entrypoints": ["arcane-os/local-ai/whisper/openvino-build"],
+      "primaryImport": "arcane-os/local-ai/whisper/openvino-build",
+      "group": "Core native speech",
+      "summary": "Produces the optional Intel NPU encoder runtime from installed matching Whisper/OpenVINO sources and an existing Windows x64 toolchain.",
+      "availability": "Windows x64 Node with Whisper 1.9.4 source, OpenVINO 2026.3.1 development tree and compatible CMake/MSVC; other platform distributions require separate native producers",
+      "protocol": "Owned configure/build process lifecycle and complete native runtime assembly",
+      "normalization": "Returns version/openvinoVersion/platform/architecture/encoder/backend/backends/root/directory/libraryDirectory/copied sourceDirectory and complete configure/compile diagnostics; retains NPU/CPU and optional supplied CUDA libraries plus notices, preserves process failures and cancellation, installs no model, driver or toolchain"
+    },
+    {
+      "id": "codex-app-server:createCodexAppServerSession",
+      "name": "createCodexAppServerSession",
+      "displayName": "createCodexAppServerSession()",
+      "kind": "function",
+      "signature": "createCodexAppServerSession({executable,args,cwd,env,clientInfo,capabilities}={})",
+      "entrypoints": ["arcane-os/codex/app-server"],
+      "primaryImport": "arcane-os/codex/app-server",
+      "group": "Native Codex sessions",
+      "summary": "Creates an explicit native Codex App Server JSONL session without starting its process until connect.",
+      "availability": "Node with caller-selected native executable on Windows, Linux and macOS; Android requires host process adaptation",
+      "protocol": "Native Codex App Server JSONL",
+      "normalization": "Complete request/result/notification objects; ordered live delta/item callbacks, actual terminal turn outcomes and exact stored-turn recovery. Server requests retain real IDs and explicit replies. No automatic thread selection, retry, approval or desktop-task attachment."
+    },
+    {
+      "id": "codex-app-server:openCodexAppServerSession",
+      "name": "openCodexAppServerSession",
+      "displayName": "openCodexAppServerSession()",
+      "kind": "function",
+      "signature": "async openCodexAppServerSession(options)",
+      "entrypoints": ["arcane-os/codex/app-server"],
+      "primaryImport": "arcane-os/codex/app-server",
+      "group": "Native Codex sessions",
+      "summary": "Creates and connects the same explicit native session, disposing it before rejecting failed initialization.",
+      "availability": "Node with caller-selected native Codex executable",
+      "protocol": "Native Codex App Server JSONL",
+      "normalization": "Returns the connected session; creates or resumes no thread and changes no provider or authentication selection."
+    },
+    {
+      "id": "mcp-stdio:createMcpStdioServer",
+      "name": "createMcpStdioServer",
+      "displayName": "createMcpStdioServer()",
+      "kind": "function",
+      "signature": "createMcpStdioServer({serverInfo,instructions,tools=[],resources=[],onDiagnostic}={})",
+      "entrypoints": ["arcane-os/mcp/stdio"],
+      "primaryImport": "arcane-os/mcp/stdio",
+      "group": "MCP STDIO",
+      "summary": "Owns one MCP STDIO session for caller-authored tools and static resources.",
+      "availability": "Node streams on Windows, Linux and macOS; Android requires host adaptation",
+      "protocol": "MCP 2025-11-25 initialize-era JSON-RPC newline transport",
+      "normalization": "Explicit CallToolResult/ReadResourceResult preserve complete content. Returns start, cancel, drain, close and closed; concurrent handlers, ordered output, cooperative cancellation and graceful EOF drain. No process launch or application-service ownership."
+    },
+    {
+      "id": "mcp-stdio:MCP_PROTOCOL_VERSION",
+      "name": "MCP_PROTOCOL_VERSION",
+      "displayName": "MCP_PROTOCOL_VERSION",
+      "kind": "constant",
+      "signature": "MCP_PROTOCOL_VERSION",
+      "entrypoints": ["arcane-os/mcp/stdio"],
+      "primaryImport": "arcane-os/mcp/stdio",
+      "group": "MCP STDIO",
+      "summary": "The explicit supported MCP initialization profile, 2025-11-25.",
+      "availability": "Node",
+      "protocol": "MCP initialization version negotiation",
+      "normalization": "Later profiles and optional unimplemented capabilities are not implied."
+    },
+    {
+      "id": "mcp-stdio:McpProtocolError",
+      "name": "McpProtocolError",
+      "displayName": "McpProtocolError",
+      "kind": "class",
+      "signature": "new McpProtocolError(code,message,data)",
+      "entrypoints": ["arcane-os/mcp/stdio"],
+      "primaryImport": "arcane-os/mcp/stdio",
+      "group": "MCP STDIO",
+      "summary": "Represents an explicit JSON-RPC failure with complete message and optional data.",
+      "availability": "Node",
+      "protocol": "JSON-RPC error object",
+      "normalization": "Preserves code, message and supplied data; ordinary tool domain failures use CallToolResult.isError."
+    },
     {
       "id": "core-repositories:resolveArcaneDataPaths",
       "name": "resolveArcaneDataPaths",
@@ -31,14 +157,28 @@
       "name": "createRepositoryWorkspace",
       "displayName": "createRepositoryWorkspace()",
       "kind": "function",
-      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,branch,onEvent,run=runProcess}={})",
+      "signature": "createRepositoryWorkspace({name,directory,dataRoot,remote,branch,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, pull, push and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are inspected without rewriting, resetting or pulling. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work."
+      "normalization": "Returns directory, open, status, pull, push, write and identical close/drain/dispose hooks. Only missing or empty destinations clone; existing roots are inspected without rewriting, resetting or pulling. Explicit paths remain selected. Same-directory operations serialize within the process; cancellation and shutdown join accepted process work. write snapshots exact selected text and paths, writes files, stages/commits only literal owned paths and non-force pushes, preserving unrelated staged files and ordinary Git filters. Complete outputs and causal failures retain confirmed local/committed/pushed and uncertain outcomes. Optional gitIdentity captures name/email/username for child Git operations only; omitted fields remain inherited and no config file is written."
+    },
+    {
+      "id": "core-repositories:readGitIdentity",
+      "name": "readGitIdentity",
+      "displayName": "readGitIdentity()",
+      "kind": "function",
+      "signature": "readGitIdentity({directory,signal,onEvent,run=runProcess}={})",
+      "entrypoints": ["arcane-os/core/repositories"],
+      "primaryImport": "arcane-os/core/repositories",
+      "group": "Native repository workspaces",
+      "summary": "Reads separate global, repository-local and effective non-secret Git identity configuration.",
+      "availability": "Node with Git on Windows, Linux and macOS; Android requires host process adaptation",
+      "protocol": "Git config NUL-delimited transport through the SDK process adapter",
+      "normalization": "Returns {global,local,effective} observations with complete name/email/githubUser strings or null when unset. Empty strings and configured includes are preserved. Without directory only global is observed and local/effective are null. Concurrent scope reads join process cleanup; complete failures propagate singly or through AggregateError. Changes no config files and claims no authenticated account or environment-resolved author."
     },
     {
       "id": "core-speech:createSpeechService",
@@ -199,14 +339,14 @@
       "name": "createGitTextSnapshot",
       "displayName": "createGitTextSnapshot()",
       "kind": "function",
-      "signature": "createGitTextSnapshot({cacheDirectory,remote,ref,selectPath,onEvent,run=runProcess}={})",
+      "signature": "createGitTextSnapshot({cacheDirectory,remote,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. 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 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",
@@ -4082,6 +4222,34 @@
       "protocol": "arcane/1 renderer client ownership",
       "normalization": "Recognizes ESM and classic SDK installation identity; returns null after close or terminal failure and does not treat a foreign Arcane facade as an SDK client"
     },
+    {
+      "id": "core-client:subscribeCoreClient",
+      "name": "subscribeCoreClient",
+      "displayName": "subscribeCoreClient()",
+      "kind": "function",
+      "signature": "subscribeCoreClient(listener,{global=globalThis,emitCurrent=true,signal}={})",
+      "entrypoints": ["arcane-os/core/client"],
+      "primaryImport": "arcane-os/core/client",
+      "group": "Core browser client",
+      "summary": "Observes exact SDK client installation and retirement with current-state replay without creating a transport.",
+      "availability": "Browser and native WebView JavaScript hosts",
+      "protocol": "Core client installation lifecycle",
+      "normalization": "Preserves client and error identities; reports current, installed, closed and transport-failed with previousClient; returns idempotent unsubscribe and supports AbortSignal. Installation does not imply runtime, service or model readiness"
+    },
+    {
+      "id": "core-development:createDevelopmentCore",
+      "name": "createDevelopmentCore",
+      "displayName": "createDevelopmentCore()",
+      "kind": "function",
+      "signature": "createDevelopmentCore({appRoot=process.cwd(),application,version,services=[],serviceModules=[],context={},getReplayEvents,signal,onEvent}={})",
+      "entrypoints": ["arcane-os/core/development", "arcane-os"],
+      "primaryImport": "arcane-os/core/development",
+      "group": "Core source development",
+      "summary": "Composes application Core services and document-owned HTTP/SSE transport independently of local AI.",
+      "availability": "Node on Windows, Linux and macOS; Android requires host adaptation",
+      "protocol": "arcane/1 over source-development HTTP/SSE",
+      "normalization": "Returns ready, handler, current and close synchronously; preserves factory options and explicit context, current lifecycle replay, correlated responses and chunks, document cancellation, accepted service work and owned drain. Explicit bootstrap does not block rendering or start application processes"
+    },
     {
       "id": "core-classic-source:createCoreClassicSource",
       "name": "createCoreClassicSource",

package/docs/reference/inventory/runtime-modules.json

@@ -120,6 +120,7 @@
         "AI_RUNTIME_STARTUP_EVENT",
         "AI_RUNTIME_STATES",
         "AI_RUNTIME_STATE_EVENT",
+        "continuesAIRuntimeOperation",
         "getAIRuntimeState",
         "publishAIRuntimeRoleState",
         "publishAIRuntimeRolesState",
@@ -131,8 +132,8 @@
       "summary": "Sticky mutable LLM, speech-to-text, and text-to-speech lifecycle snapshots, intents, subscriptions, and startup-settlement barriers.",
       "availability": "Cross-host in-process state contract; actual role readiness remains provider specific",
       "protocol": "arcane-ai-runtime-state/1 over the per-realm globalThis.arcaneEvents authority",
-      "normalization": "Closed monotonic sticky role snapshots, transient lifecycle intents, synchronous current-state replay, AbortSignal cleanup, and startup settlement are normalized; events report state but grant no authority.",
-      "surface": "Protocol/event/role/state constants; snapshot, state subscribe/publish, intent request/subscribe, and `startAIRuntime({startMuted,startTranscription,signal})` returning `{barrier,settled,cancel}`."
+      "normalization": "Closed monotonic sticky role snapshots, transient lifecycle intents, synchronous current-state replay, AbortSignal cleanup, and startup settlement are normalized; unloaded recovery/error may retain the exact busy operation until settlement, without readiness for new inference.",
+      "surface": "Protocol/event/role/state constants; snapshot, state subscribe/publish, intent request/subscribe, continuesAIRuntimeOperation(previous,current,operationId) for the real continuing runtime operation, and `startAIRuntime({startMuted,startTranscription,signal})` returning `{barrier,settled,cancel}`."
     },
     {
       "file": "runtime/arcane/modules/AnsiText.js",
@@ -1012,13 +1013,14 @@
       "kind": "esm",
       "exports": [
         "isOllamaModelIdentifier",
-        "normalizeOllamaModelIdentifier"
+        "normalizeOllamaModelIdentifier",
+        "sameOllamaModelIdentifier"
       ],
-      "summary": "Validates and canonicalizes the syntax of Ollama model identifiers without granting model admission.",
+      "summary": "Recognizes Ollama model identifier syntax and compares ordinary resident-model aliases without changing requests.",
       "availability": "Cross-host",
       "protocol": "In-process only",
-      "normalization": "Fully normalized string/boolean result.",
-      "surface": "`normalizeOllamaModelIdentifier()`, `isOllamaModelIdentifier()`."
+      "normalization": "Exact identifier/null or boolean results; alias comparison applies Ollama's default registry, namespace and tag without changing either input.",
+      "surface": "`normalizeOllamaModelIdentifier()`, `isOllamaModelIdentifier()`, `sameOllamaModelIdentifier(left, right)`."
     },
     {
       "file": "runtime/arcane/modules/OllamaSettings.js",