mindvest-atlas 0.95.1 → 0.96.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.95.1",
+  "version": "0.96.0",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/commands/memory.js

@@ -43,9 +43,19 @@ function printCard(card) {
   println(`  ${color.bold(lines[0])}`);
   for (const l of lines.slice(1)) println(`  ${l}`);
   const project = card.project || card.source?.project;
-  println(color.dim(`    ${card.kind}${project ? ` · ${project}` : ''} · w${card.weight} · used ${card.score} · ${fade(card)} · stored ${stored(card)} · ${card.id.slice(0, 8)}`));
+  const by = card.by || card.source?.by;
+  println(color.dim(`    ${card.kind}${project ? ` · ${project}` : ''} · w${card.weight} · used ${card.score} · ${fade(card)} · stored ${stored(card)}${by ? ` by ${by}` : ''} · ${card.id.slice(0, 8)}`));
 }
 
+// WHO IS WRITING (owner, 2026-10-08: "they say claude gpt etc. To say who
+// stored this"). A model running this from a chat passes its own name with
+// `--by claude`; the app keeps it on the memory. A person at a terminal says
+// nothing and is the CLI. A name is a short plain word, never free text.
+const whoSays = (flags) => {
+  const said = String(flags?.by ?? '').trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9._+-]/g, '').slice(0, 40);
+  return said || 'cli';
+};
+
 export async function memoryCommand(args) {
   const flags = args.flags || {};
   const at = askAddress(flags.root);
@@ -97,7 +107,7 @@ export async function memoryCommand(args) {
           project: flags.project === undefined
             ? (process.env.ATLAS_JOB || undefined)
             : (typeof flags.project === 'string' ? flags.project : ''),
-          by: 'cli',
+          by: whoSays(flags),
         });
         println('Remembered.');
         printCard(out.memory);
@@ -111,7 +121,7 @@ export async function memoryCommand(args) {
         const id = String(rest[0] || flags.id || '');
         const weight = Number(flags.weight ?? rest[1]);
         if (!id || !weight) { eprintln(color.red('`atlas memory weight <id> <1-10>`')); return 1; }
-        const out = await post(at, '/memory/update', { id, weight, by: 'cli' });
+        const out = await post(at, '/memory/update', { id, weight, by: whoSays(flags) });
         printCard(out.memory);
         return 0;
       }
@@ -119,7 +129,7 @@ export async function memoryCommand(args) {
       case 'demote': {
         const id = String(rest[0] || flags.id || '');
         if (!id) { eprintln(color.red(`\`atlas memory ${sub} <id> [--tier long|permanent|short]\``)); return 1; }
-        const out = await post(at, '/memory/update', { id, tier: flags.tier || (sub === 'promote' ? 'long' : 'short'), by: 'cli' });
+        const out = await post(at, '/memory/update', { id, tier: flags.tier || (sub === 'promote' ? 'long' : 'short'), by: whoSays(flags) });
         printCard(out.memory);
         return 0;
       }
@@ -127,7 +137,7 @@ export async function memoryCommand(args) {
       case 'unpin': {
         const id = String(rest[0] || flags.id || '');
         if (!id) { eprintln(color.red(`\`atlas memory ${sub} <id>\``)); return 1; }
-        const out = await post(at, '/memory/update', { id, pinned: sub === 'pin', by: 'cli' });
+        const out = await post(at, '/memory/update', { id, pinned: sub === 'pin', by: whoSays(flags) });
         printCard(out.memory);
         return 0;
       }
@@ -138,7 +148,7 @@ export async function memoryCommand(args) {
         // came back, so forgetting by the 8-character id it shows (which forget
         // did not accept) said Forgotten and removed nothing. A miss is an
         // error from the app now; this reports only what it was told.
-        const out = await post(at, '/memory/forget', { id, why: flags.why || 'removed from the CLI', by: 'cli' });
+        const out = await post(at, '/memory/forget', { id, why: flags.why || 'removed from the CLI', by: whoSays(flags) });
         if (!out.forgotten) { eprintln(color.red(`Nothing was forgotten: no memory matched "${id}".`)); return 1; }
         println(`Forgotten (${out.id || id}). It is in the trash for 30 days: \`atlas memory restore ${String(out.id || id).slice(0, 8)}\`.`);
         return 0;
@@ -246,7 +256,7 @@ export async function memoryCommand(args) {
         const out = await post(at, '/memory/list', {});
         const verdict = out.queue.find((v) => v.id === id || v.id.startsWith(id));
         if (!verdict) { eprintln(color.red('No proposal by that id. `atlas memory review` lists them.')); return 1; }
-        await post(at, '/memory/decide', { verdict, accept: sub === 'accept', by: 'cli' });
+        await post(at, '/memory/decide', { verdict, accept: sub === 'accept', by: whoSays(flags) });
         println(sub === 'accept' ? 'Done.' : 'Kept as it was.');
         return 0;
       }

package/src/commands/remote-control.js

@@ -29,6 +29,7 @@ import {
   SCRIPTS_DIR, projectsForAlert, readMode,
   streamStudioFrames,
   localBrokers, localBrokerCall,
+  localMemory,
   studioVoice,
   appendSaid,
 } from '../remote-control.js';
@@ -490,6 +491,16 @@ async function handleAsk(ask, root) {
       .catch((err) => answer(ask.request_id, { ok: false, error: String(err.message || err) }));
     return undefined;
   }
+  // MEMORY SHARING (owner, 2026-10-08): what Atlas Studio remembers on this
+  // computer, read or changed from the web, the phone or a tool. Not awaited:
+  // a write checks the new memory against the old ones with a model, which
+  // can take a minute, and the stream must keep serving everyone else.
+  if (ask.op === 'memory') {
+    void localMemory(ask.what, ask.data, root)
+      .then((out) => answer(ask.request_id, out && typeof out === 'object' ? out : { ok: false, error: 'No answer.' }))
+      .catch((err) => answer(ask.request_id, { ok: false, error: String(err.message || err) }));
+    return undefined;
+  }
   if (ask.op === 'voice') {
     // A voice the person is talking to on their phone, working Atlas Studio
     // on this computer: one screen tool, carried out by the app itself.

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.95.1';
+export const VERSION = '0.96.0';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/remote-control.js

@@ -2018,6 +2018,36 @@ export async function localBrokerCall(connector, tool, args, root, timeoutMs = 1
   return out;
 }
 
+// What a person's computer answers about its memory when the web, the phone or
+// an assistant asks (the server's `op: 'memory'`): the endpoints Atlas Studio's
+// own memory already has, by name. Anything else is refused here, before the
+// app is asked.
+export const MEMORY_OPS = ['list', 'recall', 'tension', 'write', 'update', 'forget', 'restore'];
+
+/**
+ * One memory request, answered by Atlas Studio on THIS computer.
+ *
+ * The store is the app's (`.studio/memory`); this only passes the question to
+ * it and the answer back, the way `atlas memory` does from a terminal. Memory
+ * sharing is the person's own switch on the web (Profile, Memory): the server
+ * asks nothing of a computer while it is off.
+ */
+export async function localMemory(what, data, root, timeoutMs = 150000) {
+  const op = String(what || '').trim().toLowerCase();
+  if (!MEMORY_OPS.includes(op)) return { ok: false, error: `unknown memory request ${op || '(none)'}` };
+  const at = askAddress(root);
+  if (!at) return { ok: false, error: 'Atlas Studio is not open on this computer. It holds the memory.' };
+  const res = await fetch(at.url.replace('/ask', `/memory/${op}`), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': at.token },
+    body: JSON.stringify(data && typeof data === 'object' && !Array.isArray(data) ? data : {}),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const out = await res.json().catch(() => ({}));
+  if (!res.ok) return { ok: false, error: out.error || `The memory request failed (${res.status}).` };
+  return out && typeof out === 'object' ? out : { ok: false, error: 'No answer.' };
+}
+
 /**
  * A VOICE THE PERSON IS TALKING TO SOMEWHERE ELSE, WORKING ATLAS STUDIO HERE
  * (owner, 2026-10-06: "when I switch to local, where is the voice ... it