@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -6,6 +6,21 @@ are forward-only: keep a stopped-daemon backup before upgrading.
 
 ## [Unreleased]
 
+## [0.0.2] - 2026-10-19
+
+- Add the complete pinned Pi provider catalog, model listing, API-key and OAuth setup, and cloud credentials.
+- Validate all ten chat APIs at dispatch, preserve provider-bound recovery and usage, and allow uncapped subscription routes for durable tasks with an explicit token-budget opt-out, while preserving request/runtime limits and rejecting unsupported token caps.
+- Add admitted native specialist profiles, immutable repository evidence, reviewer
+  findings, durable task-step assignments and passive team messages.
+- Give coding specialists private drafts with explicit hash-bound integration,
+  protected human edits and fresh parent acceptance checks.
+- Add pinned Gemini ACP, Claude ACP and Codex app-server workers with isolated
+  execution, concrete shared approvals and durable invocation/recovery records.
+- Add pinned A2A analysis peers, private one-use inbound grants, owned task
+  reconciliation and named Hermes/OpenClaw transport interoperability.
+- Show native, harness and peer workers together in the Salaam terminal, with
+  saved identities across disconnects and explicit recovery of uncertain work.
+
 ## [0.0.1] - 2026-10-18
 
 Initial release preparation. A version entry is not a published release; see GitHub

package/README.md

@@ -38,27 +38,30 @@ Use **Node 26.7.0** and npm **11.19.0**. macOS and Linux are supported; Windows
 not currently tested. Packages include compiled CLI code and pinned production
 dependencies. No compiler, checkout or database server is needed.
 
-Download `install.sh` from a [published release](https://github.com/SuperJackfruitLabs/salaam/releases),
-inspect it, then run:
+Install the latest stable release:
 
 ```sh
-sh install.sh --version 0.0.1
+curl -fsSL https://salaam.sh/install.sh | sh
 salaam --version
 sal --help
 ```
 
 The installer verifies the release tarball's SHA-256 checksum and installs both
-executable names. Use `--prefix "$HOME/.local"` for a private prefix and add its
-`bin` directory to `PATH`.
+executable names. You can [read the installer](https://salaam.sh/install.sh) before
+running it. To choose a version or private prefix, pass arguments to `sh`:
 
-An npm registry installation is supported **after the package is published**:
+```sh
+curl -fsSL https://salaam.sh/install.sh | sh -s -- --version 0.0.2 --prefix "$HOME/.local"
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+Or install from npm:
 
 ```sh
-npm install --global @superjackfruitlabs/salaam@0.0.1 --ignore-scripts
+npm install --global @superjackfruitlabs/salaam@0.0.2 --ignore-scripts
 ```
 
-Release preparation does not itself publish a version. Check GitHub Releases and
-npm for availability. See [installation and upgrades](docs/install.md) for direct
+See [installation and upgrades](docs/install.md) for direct
 tarball installation, prerequisites and safe state migration.
 
 ## Your first session
@@ -75,6 +78,8 @@ sal attach SESSION_ID --state /tmp/salaam-try
 Replace `SESSION_ID` with the returned ID. Enter an instruction, detach with
 Ctrl+D, then attach again. Ctrl+K opens actions; Ctrl+O opens approvals.
 
+Choose a provider with `sal providers list` and a model with `sal models list PROVIDER`. Salaam exposes all 41 chat providers in pinned Pi, including API-key, OAuth and cloud authentication. ChatGPT subscription routes support interactive sessions and durable tasks that explicitly disable token budgeting; these routes cannot enforce an output-token ceiling.
+
 For Claude, use the hidden terminal prompt and a separate provider-bound service:
 
 ```sh
@@ -89,14 +94,17 @@ by OS permissions. See [providers and credentials](docs/providers.md).
 
 ## What stays with the work
 
-| Capability                               | What it means                                                                                                                |
-| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| [Sessions](docs/service-reference.md)    | Durable dispatch, client outboxes, controller leases and committed event replay.                                             |
-| [Coding](docs/coding.md)                 | Owned workspace copies, hash-bound patches and isolated commands through a proven Docker backend.                            |
-| [Tasks](docs/durable-tasks.md)           | Stable steps, checked plans, budgets, checkpoints and opt-in bounded progression. Model text cannot complete a checked task. |
-| [Jobs and schedules](docs/jobs.md)       | Occurrence deduplication, immutable recurring templates and explicit missed-run and timezone/DST policies.                   |
-| [Host operation](docs/host-operation.md) | Reviewed runtime/backend manifests, bounded supervisor restart and a shared CLI/TUI/ACP inbox.                               |
-| [Clients](docs/clients.md)               | Terminal attachment, SSH and ACP v1 against the same service.                                                                |
+| Capability                                       | What it means                                                                                                                |
+| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
+| [Sessions](docs/service-reference.md)            | Durable dispatch, client outboxes, controller leases and committed event replay.                                             |
+| [Coding](docs/coding.md)                         | Owned workspace copies, hash-bound patches and isolated commands through a proven Docker backend.                            |
+| [Tasks](docs/durable-tasks.md)                   | Stable steps, checked plans, budgets, checkpoints and opt-in bounded progression. Model text cannot complete a checked task. |
+| [Specialists and teams](docs/agents.md)          | Admitted profiles, isolated coding proposals, explicit integration, durable task-step claims and passive messages.           |
+| [External harnesses](docs/external-harnesses.md) | Pinned Gemini, Claude ACP and Codex workers with explicit invocation limits and shared approvals.                            |
+| [A2A peers](docs/a2a.md)                         | Authenticated, bounded peer analysis, explicit inbound grants and durable task ownership.                                    |
+| [Jobs and schedules](docs/jobs.md)               | Occurrence deduplication, immutable recurring templates and explicit missed-run and timezone/DST policies.                   |
+| [Host operation](docs/host-operation.md)         | Reviewed runtime/backend manifests, bounded supervisor restart and a shared CLI/TUI/ACP inbox.                               |
+| [Clients](docs/clients.md)                       | Terminal attachment, SSH and ACP v1 against the same service.                                                                |
 
 ## Read this before trusting it
 

package/dist/src/a2a-backend.js

@@ -0,0 +1,225 @@
+import { canonical, digest, ServiceError } from './protocol.js';
+import { hostDigests } from './host.js';
+import { A2AHttp, A2A_PIN, a2aObject, privateJSON, validatePeer, } from './a2a-peer.js';
+import { A2AInvocation } from './a2a-protocol.js';
+/** Bounded outbound analysis. A peer has no local file/command/controller authority. */
+export class A2ABackend {
+    config;
+    peers;
+    ready = false;
+    active = new Map();
+    trees = new Map();
+    constructor(config) {
+        this.config = config;
+        this.peers = this.read();
+    }
+    read() {
+        const config = a2aObject(privateJSON(this.config));
+        if (Object.keys(config).sort().join(',') !== 'peers,schema' ||
+            config.schema !== 1 ||
+            !Array.isArray(config.peers) ||
+            !config.peers.length ||
+            config.peers.length > 16)
+            throw Error('Expected bounded A2A peer registry schema 1');
+        const peers = config.peers.map(validatePeer);
+        if (new Set(peers.map((p) => p.id)).size !== peers.length)
+            throw Error('Duplicate peer identity');
+        return peers;
+    }
+    descriptor(p) {
+        return {
+            id: p.id,
+            kind: 'a2a',
+            target: 'a2a',
+            version: A2A_PIN.wire,
+            config_digest: digest(p),
+            adapter_digest: hostDigests().build_digest,
+            execution_identity: {
+                version: A2A_PIN.wire,
+                kernel: 'remote-unobserved',
+                arch: 'remote-unobserved',
+            },
+            boundary_digest: digest({ protocol: A2A_PIN, peer: p, authority: 'remote-analysis-only' }),
+            engine_id: p.id,
+            evidence: 'proven',
+            model_usage: 'unknown',
+            output_cap: null,
+            max_model_requests: null,
+            files: false,
+            commands: false,
+        };
+    }
+    async prepare() {
+        this.peers = this.read();
+        this.ready = true;
+    }
+    async close() {
+        this.active.clear();
+        this.trees.clear();
+        this.ready = false;
+    }
+    runtimes() {
+        return this.ready ? this.peers.map((p) => this.descriptor(p)) : [];
+    }
+    validate(runtime) {
+        const p = this.read().find((p) => p.id === runtime.id);
+        if (!this.ready || !p || canonical(this.descriptor(p)) !== canonical(runtime))
+            throw Error('A2A peer/config/credential/build admission changed');
+    }
+    assertAuthority(_runtime, tools) {
+        if (tools.some((t) => [
+            'salaam_files',
+            'salaam_command',
+            'salaam_team',
+            'salaam_managed',
+            'salaam_children',
+        ].includes(t)))
+            throw Error('A2A peers are analysis specialists without local tools');
+    }
+    async execute(binding, run, prompt, tree, hooks) {
+        this.validate(binding.external);
+        this.assertAuthority(binding.external, binding.tools);
+        hooks.assertActive();
+        if (this.active.has(run) || this.trees.has(run))
+            throw Error('A2A invocation cannot be replayed');
+        const p = this.peers.find((p) => p.id === binding.external.id), http = new A2AHttp(p);
+        const files = Object.create(null), disclosure = [];
+        for (const path of p.files) {
+            const f = tree[path];
+            if (!f)
+                throw Error('An explicitly disclosed repository file is absent');
+            const bytes = Buffer.from(f.content, 'base64'), text = bytes.toString('utf8');
+            if (!Buffer.from(text).equals(bytes) || bytes.length > 65536)
+                throw Error('Only bounded UTF-8 peer disclosure is supported');
+            files[path] = text;
+            disclosure.push({ path, digest: digest(f), bytes: bytes.length });
+        }
+        const data = { skill: p.skill, files }, peer = { id: p.id, tenant: p.tenant, digest: digest(p), cancel: p.cancel, skill: p.skill };
+        if (canonical({ prompt, data }).length > 196608)
+            throw Error('A2A disclosure exceeds bound');
+        const initial = A2AInvocation.prepare(binding.worker_id, binding.attempt_id, peer, prompt, data, disclosure);
+        initial.run_id = run;
+        // Both identity and disclosure are durable before any SendMessage bytes leave.
+        hooks.checkpoint(initial);
+        hooks.receipt(initial);
+        const invocation = new A2AInvocation(peer, initial, http, (cp) => {
+            hooks.checkpoint(cp);
+            hooks.receipt(cp);
+            return undefined;
+        });
+        this.active.set(run, invocation);
+        this.trees.set(run, structuredClone(tree));
+        await http.card();
+        hooks.assertActive();
+        let task = await invocation.dispatch(prompt, data);
+        const end = Date.now() + 180000;
+        while (invocation.view().state !== 'terminal') {
+            hooks.assertActive();
+            this.validate(binding.external);
+            if (['TASK_STATE_INPUT_REQUIRED', 'TASK_STATE_AUTH_REQUIRED'].includes(task.status.state))
+                throw Error('Peer needs input/authentication; explicit operator resolution required');
+            if (Date.now() >= end)
+                throw Error('Peer deadline reached; remote work may still run');
+            if (p.streaming) {
+                try {
+                    await http.subscribe(invocation.view().task_id, (event) => {
+                        hooks.assertActive();
+                        invocation.observe(event);
+                    });
+                }
+                catch (error) {
+                    if (error instanceof ServiceError)
+                        throw error;
+                }
+            }
+            else
+                await new Promise((r) => setTimeout(r, 2500));
+            hooks.assertActive();
+            task = await invocation.inspect();
+        }
+        if (task.status.state !== 'TASK_STATE_COMPLETED')
+            throw Error('Remote task ended without a completed result');
+        return {
+            result: {
+                peer: p.id,
+                tenant: p.tenant,
+                task,
+                disclosure,
+                prompt_digest: digest(prompt),
+                verified_success: false,
+                remote_execution: 'unobserved',
+            },
+        };
+    }
+    collect(run) {
+        const tree = this.trees.get(run);
+        if (!tree)
+            throw Error('No owned local snapshot for remote analysis');
+        this.trees.delete(run);
+        return tree;
+    }
+    async stop(run, runtime, receipt) {
+        this.validate(runtime);
+        let invocation = this.active.get(run);
+        if (!invocation) {
+            const record = a2aObject(receipt);
+            const cp = a2aObject(record.checkpoint ?? record), p = this.peers.find((p) => p.id === runtime.id);
+            if (cp.run_id !== run)
+                throw Error('Remote cleanup receipt belongs to another local run');
+            invocation = new A2AInvocation({ id: p.id, tenant: p.tenant, digest: digest(p), cancel: p.cancel, skill: p.skill }, cp, new A2AHttp(p), () => undefined);
+        }
+        if (invocation.view().state === 'prepared') {
+            this.active.delete(run);
+            this.trees.delete(run);
+            return { scope: 'never-dispatched', checkpoint: invocation.view() };
+        }
+        await invocation.cancel();
+        if (invocation.view().state !== 'terminal')
+            throw Error('Remote terminal receipt is unconfirmed');
+        this.active.delete(run);
+        if (invocation.view().result?.status.state !== 'TASK_STATE_COMPLETED')
+            this.trees.delete(run);
+        return { scope: 'remote-terminal-receipt', checkpoint: invocation.view() };
+    }
+}
+export class ExternalBackends {
+    backends;
+    constructor(backends) {
+        this.backends = backends;
+    }
+    async prepare() {
+        for (const b of this.backends)
+            await b.prepare?.();
+        const ids = this.runtimes().map((r) => r.id);
+        if (new Set(ids).size !== ids.length)
+            throw Error('Runtime IDs must be unique across local and remote backends');
+    }
+    async close() {
+        for (const b of this.backends)
+            await b.close?.();
+    }
+    runtimes() {
+        return this.backends.flatMap((b) => b.runtimes());
+    }
+    owner(runtime) {
+        const b = this.backends.find((b) => b.runtimes().some((r) => r.id === runtime.id));
+        if (!b)
+            throw Error('Runtime is unavailable');
+        return b;
+    }
+    validate(runtime) {
+        this.owner(runtime).validate(runtime);
+    }
+    assertAuthority(runtime, tools) {
+        this.owner(runtime).assertAuthority?.(runtime, tools);
+    }
+    execute(binding, run, prompt, tree, hooks) {
+        return this.owner(binding.external).execute(binding, run, prompt, tree, hooks);
+    }
+    collect(run, runtime) {
+        return this.owner(runtime).collect(run, runtime);
+    }
+    stop(run, runtime, receipt) {
+        return this.owner(runtime).stop(run, runtime, receipt);
+    }
+}