@brunobracaioli/aibrain 0.3.0-beta.18 → 0.4.0-beta.1

package/README.md

@@ -1,6 +1,18 @@
-# aibrain
+# aisac
 
-Assisted AI Brain context beta client for Linux/WSL with Node.js 22 or newer.
+The AISAC client for Claude Code and Codex on Linux/WSL with Node.js 22 or newer:
+AI Brain memory, context management and, for AISAC Founding Cohort members,
+AISAC Engineering.
+
+The command is `aisac`. `aibrain` is an alias for the same program, so existing
+scripts and habits keep working. The same files are published as `@aisac/cli`
+and, for existing installs, `@brunobracaioli/aibrain`. Install only one of them:
+both provide the `aisac` and `aibrain` commands. State stays in `~/.aibrain`.
+
+`aisac setup` and `aisac doctor` report the AISAC Engineering license
+(`active`, `inactive` or `unavailable`). The server decides; the client only
+shows the answer and sends the request only to the configured AI Brain address.
+`aisac status` stays offline.
 
 Codex capture also requires the `flock` utility from `util-linux`, normally
 included in Linux/WSL. The launcher and doctor check availability before a
@@ -34,13 +46,17 @@ connection. Its failure or timeout closes only that auxiliary connection.
 
 ```sh
 # Install the published beta:
-npm install -g @brunobracaioli/aibrain@beta
-aibrain setup --client both
-aibrain doctor --json
-aibrain claude
-aibrain codex
+npm install -g @aisac/cli@beta
+aisac setup --client both
+aisac doctor --json
+aisac claude
+aisac codex
 ```
 
+To move from `@brunobracaioli/aibrain` to `@aisac/cli`, close running sessions,
+then run `npm uninstall -g @brunobracaioli/aibrain` before
+`npm install -g @aisac/cli@beta`. Setup, notes and checkpoints are kept.
+
 Installation does not contact AI Brain, change native client configuration, or
 enable all paid accounts. Setup requires an existing AI Brain PAT, explicit
 versioned disclosure, and successful provider-free pilot access. Claude and
@@ -53,10 +69,10 @@ explicitly acknowledge the displayed disclosure with
 `aibrain setup --client both --token-file /private/path/brain.pat
 --accept-disclosure`.
 
-For a CI-reviewed tarball, use
-`brunobracaioli-aibrain-*.tgz` with
-`npm install -g ./brunobracaioli-aibrain-*.tgz`; registry installation is gated on
-the operator's npm review and authentication.
+For a CI-reviewed tarball, use `aisac-cli-*.tgz` with
+`npm install -g ./aisac-cli-*.tgz` (the same files are also packed as
+`brunobracaioli-aibrain-*.tgz`); registry installation is gated on the
+operator's npm review and authentication.
 
 For users of an earlier unscoped review tarball, close its client sessions,
 run `npm uninstall -g aibrain`, and install this scoped package. Local

package/dist/assets/claude/hooks/context-compaction.ts

@@ -151,7 +151,7 @@ type Register = (
 ) => void;
 
 const MAX_RESULT_BYTES = 256 * 1024;
-const CLAUDE_HOOK_VERSION = '0.3.0-beta.18';
+const CLAUDE_HOOK_VERSION = '0.4.0-beta.1';
 const MAX_DIAGNOSTIC_BYTE_COUNT = 128 * 1024 * 1024;
 const COOLDOWN_MS = 60_000;
 const MAX_TRUNCATED_CODE_POINTS = 300;

package/dist/claude-compatibility.mjs

@@ -494,7 +494,7 @@ export async function resolveClaudeCompatibility(executable, packageRoot) {
 /** @param {ClaudeCompatibility} decision */
 export function claudeCompatibilityError(decision) {
   const detected = decision.version ?? 'unavailable';
-  return `claude_version_unverified: Claude Code detected version ${detected}; reason ${decision.reason}; run aibrain doctor --json or install a compatible stable native version.`;
+  return `claude_version_unverified: Claude Code detected version ${detected}; reason ${decision.reason}; run aisac doctor --json or install a compatible stable native version.`;
 }
 
 export const claudeCompatibilityInternals = Object.freeze({

package/dist/claude-observation.mjs

@@ -16,7 +16,7 @@ export const MAX_LOG_FILES = 3;
 const LOCK_WAIT_MS = 250;
 const LOCK_STALE_MS = 30_000;
 const ADMISSION_MS = 60 * 60 * 1000;
-export const ADAPTER_VERSION = '0.3.0-beta.18';
+export const ADAPTER_VERSION = '0.4.0-beta.1';
 const MAX_DIAGNOSTIC_COUNT = 10_000_000;
 const MAX_DIAGNOSTIC_BYTES = 128 * 1024 * 1024;
 const CHECKPOINT_BACKENDS = new Set(['native_store', 'private_file']);

package/dist/cli.mjs

@@ -28,15 +28,18 @@ import { providerFreeProbe } from './mcp.mjs';
 import { codexPolicyJson, makePolicy, publicPolicy, isProfile } from './policy.mjs';
 import { readDiagnostics } from './claude-observation.mjs';
 import { readCodexDiagnostics } from './codex-diagnostics.mjs';
+import { checkEngineeringLicense, licenseLine, unavailableLicense } from './engineering.mjs';
 
-const VERSION = '0.3.0-beta.18';
+const VERSION = '0.4.0-beta.1';
+// The command is `aisac`; `aibrain` is an alias installed from the same entry.
+const COMMAND = 'aisac';
 const ENDPOINT = 'https://mcp.ai-brain.aisac.cloud/mcp';
 const PACKAGE_ROOT = dirname(fileURLToPath(import.meta.url));
 const LEGACY_DISCLOSURE_VERSION = 'aibrain-paid-context-v1-2026-10-09';
 
 function usage() {
   console.log(
-    `aibrain ${VERSION}\n\nUsage:\n  aibrain setup [--client claude|codex|both] [--context-profile upstream|conservative]\n    [--compact-at 1..95] [--keep-threshold 0..1] [--preserve-recent 1..100]\n    [--min-reduction 0..1] [--truncate-head-chars 0..4096]\n    [--max-state-tokens 1000..25000] [--max-request-tokens 1000..30000]\n    [--tool-policy compatible|read_only] [--goal TEXT]\n  aibrain doctor [--json]\n  aibrain status [--json]\n  aibrain disable\n  aibrain setup --undo\n  aibrain claude [-- native-args...]\n  aibrain codex [-- native-args...]\n\nPolicy notes:\n  Automatic monitoring asks for compaction at compact-at percent; state/request\n  limits are estimated upper bounds and do not override server quotas.\n  min-reduction, truncate-head-chars and tool-policy apply only to Claude;\n  Codex keeps native compaction and same-session recovery.`,
+    `${COMMAND} ${VERSION}\n\nUsage:\n  ${COMMAND} setup [--client claude|codex|both] [--context-profile upstream|conservative]\n    [--compact-at 1..95] [--keep-threshold 0..1] [--preserve-recent 1..100]\n    [--min-reduction 0..1] [--truncate-head-chars 0..4096]\n    [--max-state-tokens 1000..25000] [--max-request-tokens 1000..30000]\n    [--tool-policy compatible|read_only] [--goal TEXT]\n  ${COMMAND} doctor [--json]\n  ${COMMAND} status [--json]\n  ${COMMAND} disable\n  ${COMMAND} setup --undo\n  ${COMMAND} claude [-- native-args...]\n  ${COMMAND} codex [-- native-args...]\n\nPolicy notes:\n  Automatic monitoring asks for compaction at compact-at percent; state/request\n  limits are estimated upper bounds and do not override server quotas.\n  min-reduction, truncate-head-chars and tool-policy apply only to Claude;\n  Codex keeps native compaction and same-session recovery.`,
   );
   console.log(
     'Telemetry: setup --telemetry on|off (omitted preserves the stored choice; fresh defaults off).',
@@ -44,11 +47,14 @@ function usage() {
   console.log(
     'Claude shadow: setup --claude-shadow on|off and --claude-diagnostics on|off (preview stays applied=false).',
   );
+  console.log(
+    'AISAC Engineering: setup and doctor report the license; status stays offline. `aibrain` is an alias of `aisac`.',
+  );
 }
 
 // Telemetry is opt-in; setup omits the flag to preserve the stored choice.
 function version() {
-  console.log(`aibrain ${VERSION}`);
+  console.log(`${COMMAND} ${VERSION}`);
 }
 
 async function maskedPrompt() {
@@ -495,6 +501,9 @@ async function setup(args) {
   console.log(
     `Configured ${clients} in ${root}. Provider-free access verified; no provider batch was used.`,
   );
+  // Display only: the server decides again on every pack request (ADR-0047).
+  const line = licenseLine(await checkEngineeringLicense(endpoint, token));
+  if (line !== null) console.log(line);
 }
 
 /** @param {boolean} json */
@@ -534,6 +543,10 @@ async function doctor(json) {
     ...rawNativeVersions,
     codex: codexCompatibility?.version ?? rawNativeVersions.codex,
   };
+  // Optional capability: its state never changes doctor's exit code.
+  const engineering = config
+    ? await checkEngineeringLicense(config.endpoint, config.token)
+    : unavailableLicense('not_configured');
   const needsClaude = config?.clientSelection === 'claude' || config?.clientSelection === 'both';
   const needsCodex = config?.clientSelection === 'codex' || config?.clientSelection === 'both';
   const captureLockPlatform = needsCodex ? captureLockPlatformCheck() : null;
@@ -585,6 +598,7 @@ async function doctor(json) {
         config?.claudeObservation?.disclosedAt !== null &&
         config?.claudeObservation?.disclosedAt !== undefined,
     },
+    engineering,
     paidOrPilot: probe?.ok
       ? 'provider_free_probe_ok; paid entitlement or pilot invitation remains server-enforced'
       : config
@@ -716,7 +730,7 @@ main(cliArgs).catch((error) => {
       }),
     );
   } else {
-    console.error(`aibrain: ${errorMessage(error)}`);
+    console.error(`${COMMAND}: ${errorMessage(error)}`);
   }
   process.exitCode = 1;
 });

package/dist/codex-compatibility.mjs

@@ -477,5 +477,5 @@ export async function resolveCodexCompatibility(executable, baseEnvironment = pr
 
 /** @param {{reason:string, version:string|null}} decision @returns {string} */
 export function codexCompatibilityError(decision) {
-  return `codex_protocol_incompatible:${decision.reason}:detected=${decision.version ?? 'unavailable'};run aibrain doctor --json`;
+  return `codex_protocol_incompatible:${decision.reason}:detected=${decision.version ?? 'unavailable'};run aisac doctor --json`;
 }

package/dist/engineering.mjs

@@ -0,0 +1,190 @@
+// @ts-check
+
+/**
+ * AISAC Engineering license check (ADR-0047 wave E3).
+ *
+ * The server is the only authority. This answer is shown to the user and
+ * never unlocks anything locally: every failure is reported as
+ * `unavailable`, never as licensed. The account token goes only to the
+ * configured AI Brain origin, redirects are refused, and the response is
+ * size-bounded and validated before any field is displayed.
+ */
+
+const LICENSE_PATH = '/engineering/v1/license';
+export const LICENSE_TIMEOUT_MS = 5_000;
+const MAX_LICENSE_BODY_BYTES = 16 * 1024;
+const MAX_URL_LENGTH = 2_048;
+const ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u;
+// Reasons are displayed, so only a plain identifier is accepted. New server
+// reasons stay readable by old clients without an allowlist update.
+const SAFE_REASON = /^[a-z][a-z0-9_]{0,63}$/u;
+/** @type {ReadonlyMap<number, string>} */
+const UNAVAILABLE_BY_STATUS = new Map([
+  [401, 'unauthorized'],
+  [404, 'not_offered'],
+  [429, 'rate_limited'],
+  [503, 'license_unavailable'],
+]);
+const SERVER_ERROR_STATUS = 500;
+
+/**
+ * @typedef {{
+ *   state: 'active' | 'inactive' | 'unavailable',
+ *   reason: string,
+ *   validUntil: string | null,
+ *   purchaseUrl: string | null
+ * }} EngineeringLicense
+ */
+
+/** @param {string} reason @returns {EngineeringLicense} */
+export function unavailableLicense(reason) {
+  return { state: 'unavailable', reason, validUntil: null, purchaseUrl: null };
+}
+
+/** @param {string} endpoint */
+export function engineeringLicenseUrl(endpoint) {
+  return new URL(LICENSE_PATH, endpoint).toString();
+}
+
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** @param {unknown} value */
+function isPurchaseUrl(value) {
+  if (typeof value !== 'string' || value.length > MAX_URL_LENGTH) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' && url.username === '' && url.password === '';
+  } catch {
+    return false;
+  }
+}
+
+/** @param {unknown} value */
+function isValidUntil(value) {
+  return (
+    value === null ||
+    (typeof value === 'string' && ISO_INSTANT.test(value) && Number.isFinite(Date.parse(value)))
+  );
+}
+
+/**
+ * Validate the 200 body of the license route (OpenAPI `EngineeringLicense`).
+ * Unknown extra fields are ignored; anything malformed rejects the whole body.
+ * @param {string} text
+ * @returns {EngineeringLicense | null}
+ */
+export function parseLicenseBody(text) {
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord(body) || body.schema_version !== 1 || body.capability !== 'engineering')
+    return null;
+  const { state, reason, valid_until: validUntil, purchase_url: purchaseUrl } = body;
+  if (state !== 'active' && state !== 'inactive') return null;
+  if (typeof reason !== 'string' || !SAFE_REASON.test(reason)) return null;
+  if (!isValidUntil(validUntil) || !isPurchaseUrl(purchaseUrl)) return null;
+  return {
+    state,
+    reason,
+    validUntil: /** @type {string | null} */ (validUntil),
+    purchaseUrl: /** @type {string} */ (purchaseUrl),
+  };
+}
+
+/** @param {Response} response */
+async function boundedText(response) {
+  const declared = Number(response.headers.get('content-length') ?? '0');
+  if (declared > MAX_LICENSE_BODY_BYTES) throw new Error('license_body_too_large');
+  if (response.body === null) return '';
+  const reader = response.body.getReader();
+  /** @type {Uint8Array[]} */
+  const chunks = [];
+  let size = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > MAX_LICENSE_BODY_BYTES) {
+      await reader.cancel().catch(() => undefined);
+      throw new Error('license_body_too_large');
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+/** @param {unknown} error */
+function isTimeout(error) {
+  return error instanceof Error && (error.name === 'TimeoutError' || error.name === 'AbortError');
+}
+
+/** @param {number} status */
+function unavailableReasonFor(status) {
+  return (
+    UNAVAILABLE_BY_STATUS.get(status) ??
+    (status >= SERVER_ERROR_STATUS ? 'server_error' : 'unexpected_status')
+  );
+}
+
+/**
+ * Ask the server whether this account holds the AISAC Engineering license.
+ * @param {string} endpoint configured AI Brain MCP endpoint (already validated at setup)
+ * @param {string} token account PAT
+ * @param {{ fetchImpl?: typeof fetch, timeoutMs?: number }} [options]
+ * @returns {Promise<EngineeringLicense>}
+ */
+export async function checkEngineeringLicense(endpoint, token, options = {}) {
+  const { fetchImpl = fetch, timeoutMs = LICENSE_TIMEOUT_MS } = options;
+  let url;
+  try {
+    url = engineeringLicenseUrl(endpoint);
+  } catch {
+    return unavailableLicense('invalid_endpoint');
+  }
+  const signal = AbortSignal.timeout(timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: 'GET',
+      redirect: 'error',
+      signal,
+      headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+    });
+  } catch (error) {
+    return unavailableLicense(isTimeout(error) ? 'timeout' : 'unreachable');
+  }
+  if (response.status !== 200) {
+    await response.body?.cancel().catch(() => undefined);
+    return unavailableLicense(unavailableReasonFor(response.status));
+  }
+  let text;
+  try {
+    text = await boundedText(response);
+  } catch (error) {
+    return unavailableLicense(isTimeout(error) ? 'timeout' : 'invalid_response');
+  }
+  return parseLicenseBody(text) ?? unavailableLicense('invalid_response');
+}
+
+/**
+ * One line for `aisac setup`. Returns null while the server does not offer the
+ * capability yet, so memory-only users see no new noise.
+ * @param {EngineeringLicense} license
+ * @returns {string | null}
+ */
+export function licenseLine(license) {
+  if (license.state === 'active') {
+    const until = license.validUntil === null ? '' : ` until ${license.validUntil.slice(0, 10)}`;
+    return `AISAC Engineering: active${until}.`;
+  }
+  if (license.state === 'inactive')
+    return `AISAC Engineering: inactive (${license.reason}) — ${license.purchaseUrl ?? ''}`.trimEnd();
+  if (license.reason === 'not_offered') return null;
+  return `AISAC Engineering: unavailable (${license.reason}); memory and context are unaffected.`;
+}

package/dist/launch.mjs

@@ -413,7 +413,7 @@ export async function launchClaude(config, root, args) {
   const pinnedExecutable = compatibility.executable ?? executable;
   if (compatibility.status === 'host_checked')
     process.stderr.write(
-      `aibrain: Claude ${compatibility.version ?? 'unknown'} accepted by the local native host contract; end-to-end recovery remains separately qualified.\n`,
+      `aisac: Claude ${compatibility.version ?? 'unknown'} accepted by the local native host contract; end-to-end recovery remains separately qualified.\n`,
     );
   const currentVersion = compatibility.version ?? nativeVersion(pinnedExecutable);
   const pluginRoot = await assertClaudeAssets(validated.packageRoot);
@@ -575,7 +575,7 @@ export async function launchCodex(config, root, args) {
   if (compatibility.version === null) throw new Error('codex_version_unverified');
   if (compatibility.status === 'protocol_match')
     process.stderr.write(
-      `aibrain: Codex ${compatibility.version} matched the local protocol contract; native behavioral qualification is not established.\n`,
+      `aisac: Codex ${compatibility.version} matched the local protocol contract; native behavioral qualification is not established.\n`,
     );
   const launchPlan = await parseCodexLaunchArgs(args, process.cwd());
   const packageRoot = resolve(validated.packageRoot);

package/dist/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.18",
+  "version": "0.4.0-beta.1",
   "type": "module"
 }

package/dist/platform.mjs

@@ -116,7 +116,7 @@ export function nativeVersionDiagnostic(client, version) {
     : 'unavailable';
   const label = client === 'claude' ? 'Claude Code' : 'Codex CLI';
   const tested = TESTED_NATIVE_VERSIONS[client].join(', ');
-  return `${client}_version_unverified: ${label} detected version ${safeDetected}; tested stable versions: ${tested}. Update AI Brain to a compatible version, then run aibrain doctor --json or install a qualified stable native version.`;
+  return `${client}_version_unverified: ${label} detected version ${safeDetected}; tested stable versions: ${tested}. Update AI Brain to a compatible version, then run aisac doctor --json or install a qualified stable native version.`;
 }
 
 /** @param {'claude'|'codex'} client @param {string} version */

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.3.0-beta.18",
+  "version": "0.4.0-beta.1",
   "private": false,
-  "description": "AI Brain assisted context beta client for Claude Code and Codex",
+  "description": "AISAC client for Claude Code and Codex: AI Brain memory, context management and AISAC Engineering",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
+    "aisac": "./dist/cli.mjs",
     "aibrain": "./dist/cli.mjs"
   },
   "files": [