totemlayer 0.1.96 → 0.1.115

package/bin/startup-diagnostics.mjs

@@ -4,6 +4,10 @@ export const HOST_APPROVAL_RECOVERY =
   "Stop retrying. Ask the owner to inspect this command in the host app's approval or automatic review controls. If no approval path is available, contact the host's support with the denial. Resume once after the owner resolves it; do not bypass the policy or change agents.";
 
 const causes = {
+  RUNTIME_RATE_LIMITED: [
+    "Totem requests are waiting for the server's cooldown.",
+    "Keep this connection and its queued messages. Automatic recovery will wait until the reported retry time without changing request limits.",
+  ],
   CHAT_PROMPT_RATE_LIMITED: [
     "Automatic chat prompts are waiting for their existing cooldown.",
     "Keep saved messages queued. Automatic receiving will retry at the reported time without changing the chat prompt limit.",
@@ -184,7 +188,9 @@ export function startupDiagnostic(error) {
   );
   const match = chain
     .toReversed()
-    .find((item) => known(item.code) || known(item.causeCode) || [401, 403].includes(item.status));
+    .find(
+      (item) => known(item.code) || known(item.causeCode) || [401, 403, 429].includes(item.status),
+    );
   const causeCode = denied
     ? "HOST_APPROVAL_DENIED"
     : match
@@ -192,16 +198,27 @@ export function startupDiagnostic(error) {
         ? match.code
         : known(match.causeCode)
           ? match.causeCode
-          : "RUNTIME_AUTHORIZATION_REJECTED"
+          : match.status === 429
+            ? "RUNTIME_RATE_LIMITED"
+            : "RUNTIME_AUTHORIZATION_REJECTED"
       : "STARTUP_CAUSE_UNAVAILABLE";
   const [cause, recovery, retryable = true] = causes[causeCode];
   const retryAt = match?.retryAt;
   const now = Date.now();
+  const seconds = match?.retryAfterSeconds;
+  const serverRetryAt =
+    causeCode === "RUNTIME_RATE_LIMITED" &&
+    Number.isSafeInteger(seconds) &&
+    seconds > 0 &&
+    seconds <= 86400
+      ? now + seconds * 1000
+      : undefined;
   return {
     causeCode,
     cause,
     recovery,
     retryable,
+    ...(serverRetryAt ? { retryAt: serverRetryAt } : {}),
     ...(causeCode === "CHAT_PROMPT_RATE_LIMITED" &&
     Number.isFinite(retryAt) &&
     retryAt > now &&

package/bin/strict-installation.mjs

@@ -1,6 +1,7 @@
 import { parseArgs } from "node:util";
 import { GUIDE_UNAVAILABLE, runStrictSetup } from "./strict-setup.mjs";
 import { readReleaseSetupGuide } from "./setup-guide.mjs";
+import { NATIVE_INSTALL_PROVIDERS } from "./configured-native-installation.mjs";
 
 export const STRICT_INSTALL_HELP = `Install Totem with every required verification
 
@@ -9,6 +10,15 @@ export const STRICT_INSTALL_HELP = `Install Totem with every required verificati
     [--device-login --no-browser]
   totem install --read-guide
   totem install --status
+  totem install --provider pi|hermes|opencode|kilo|claude --native-config /private/binding.json
+    --session CURRENT_NATIVE_SESSION --model CURRENT_MODEL [--status] [--json]
+  totem install --provider claude --native-config /private/binding.json
+    --session CURRENT_NATIVE_SESSION --model CURRENT_MODEL --agent-id UUID --environment PRODUCTION|SANDBOX
+    --device-login [--no-browser] [--wait-seconds 1200] [--json]
+
+Native profiles use their existing sign-in and a private owner-prepared binding.
+This registers/resumes the exact native receiver; it reports incomplete until live
+receiving, restart, peer and website-owner acceptance are separately verified.
 
 Run inside the intended agent's command-capable host. The current native session and
 model must be verified; an installed client is never selected as a substitute.
@@ -37,6 +47,7 @@ export async function strictInstallationMain(args = [], options = {}) {
         environment: { type: "string" },
         "base-url": { type: "string" },
         session: { type: "string" },
+        "native-config": { type: "string" },
         model: { type: "string" },
         "wait-seconds": { type: "string", default: "1200" },
         "read-guide": { type: "boolean" },
@@ -94,8 +105,12 @@ export async function strictInstallationMain(args = [], options = {}) {
         /tn_(?:live|test)_/.test(values.model))
     )
       throw new Error();
-    if (values.session && !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(values.session))
+    const sessionPattern = values.provider === "hermes" ? /^\d{8}_\d{6}_[a-f0-9]{6}$/
+      : ["opencode", "kilo"].includes(values.provider) ? /^ses_[A-Za-z0-9]{12,80}$/
+        : /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i;
+    if (values.session && !sessionPattern.test(values.session))
       throw new Error();
+    if (values["native-config"] && !NATIVE_INSTALL_PROVIDERS.includes(values.provider)) throw new Error();
     const env = options.env ?? process.env;
     flags = {
       provider: values.provider ?? (env.CODEX_THREAD_ID ? "codex" : undefined),
@@ -106,10 +121,12 @@ export async function strictInstallationMain(args = [], options = {}) {
       model: values.model,
       waitSeconds,
       json: values.json === true,
+      ...(values["native-config"] ? { nativeConfig: values["native-config"] } : {}),
     };
     if (values["device-login"]) flags.deviceLogin = true;
     if (values["no-browser"]) flags.noBrowser = true;
-    if (values.status) {
+    if (values.status && flags.nativeConfig) flags.status = true;
+    else if (values.status) {
       flags.sessionId ??= env.CODEX_THREAD_ID;
       const { readStrictSetupJob } = await import("./strict-setup-jobs.mjs");
       const publicStatus = { ...(await readStrictSetupJob(flags, env)) };
@@ -130,6 +147,15 @@ export async function strictInstallationMain(args = [], options = {}) {
     return 2;
   }
   const write = async (value) => stdout.write(JSON.stringify(value) + "\n");
+  if (flags.nativeConfig) {
+    try {
+      const { installConfiguredNativeReceiver } = await import("./configured-native-installation.mjs");
+      await write({ ...await installConfiguredNativeReceiver(flags, { ...options, write }), complete: false });
+    } catch (error) {
+      await write({ complete: false, state: "incomplete", code: /^[A-Z][A-Z0-9_]{0,79}$/.test(error.code ?? "") ? error.code : "NATIVE_INSTALL_FAILED" });
+    }
+    return 2;
+  }
   if (!options.adapter && !options.foreground && flags.provider === "codex") {
     // Return before readiness needs a model turn in this same native chat.
     const adapter = (await import("./strict-codex-adapter.mjs")).createStrictCodexAdapter(flags, {
@@ -190,7 +216,7 @@ export async function strictInstallationMain(args = [], options = {}) {
           readGuide: readReleaseSetupGuide,
           async inspect() {
             throw Object.assign(new Error(), {
-              code: flags.provider ? "HOST_ADAPTER_UNSUPPORTED" : "EXACT_NATIVE_HOST_REQUIRED",
+              code: ["pi", "hermes", "opencode", "kilo"].includes(flags.provider) ? "NATIVE_CONFIGURATION_REQUIRED" : flags.provider ? "HOST_ADAPTER_UNSUPPORTED" : "EXACT_NATIVE_HOST_REQUIRED",
             });
           },
         });

package/bin/supervisor-watchdog.mjs

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { privateRead, privateWrite } from "./runtime-installation.mjs";
+
+/** The launcher owns this ChildProcess; never discover or signal a saved PID here. */
+export function watchSupervisorChild(child, directory, options = {}) {
+  const heartbeatFile = options.heartbeatFile ?? "supervisor.json";
+  if (!["supervisor.json", "status.json"].includes(heartbeatFile)) throw new Error("Invalid supervisor heartbeat file.");
+  const timeoutMs = options.timeoutMs ?? 300000;
+  const started = Date.now();
+  let checking = false, stopped = false, terminating = false, force;
+  const alive = () => child.exitCode === null && child.signalCode === null;
+  const stop = () => {
+    stopped = true;
+    clearInterval(timer);
+    clearTimeout(force);
+    child.removeListener("exit", stop);
+    child.removeListener("error", stop);
+  };
+  const timer = setInterval(async () => {
+    if (stopped || checking || terminating || !alive()) return;
+    checking = true;
+    try {
+      const state = await privateRead(join(directory, heartbeatFile)).catch(() => null);
+      if (stopped || !alive()) return;
+      const now = Date.now(), updated = Date.parse(state?.updatedAt);
+      // A deliberately paused dedicated inbox is quiet by design. The stored
+      // PID must still match the child this launcher owns, never another job.
+      if (options.allowPaused === true && state?.pid === child.pid && state.state === "paused") return;
+      if (now - started < timeoutMs ||
+          (state?.pid === child.pid && Number.isFinite(updated) && updated <= now + 5000 && now - updated < timeoutMs)) return;
+      terminating = true;
+      void privateWrite(join(directory, "supervisor-watchdog.json"), {
+        code: "SUPERVISOR_HEARTBEAT_TIMEOUT", pid: child.pid, updatedAt: new Date(now).toISOString(),
+      }).catch(() => {});
+      child.kill("SIGTERM");
+      force = setTimeout(() => { if (alive()) child.kill("SIGKILL"); }, options.graceMs ?? 5000);
+      force.unref();
+    } finally { checking = false; }
+  }, options.intervalMs ?? 15000);
+  timer.unref();
+  child.once("exit", stop);
+  child.once("error", stop);
+  return stop;
+}

package/bin/totem.mjs

@@ -251,6 +251,7 @@ Connect once and receive messages and approved Mission work
   totem diagnose [--profile NAME] [--fresh] [--json]
   totem repair-startup [--expected-task-sha256 HEX] [--json]
   totem start --background
+  totem supervise --help
   totem stop
 
 Agent messaging and local runtime
@@ -1755,6 +1756,11 @@ async function runRfq(options, baseUrl) {
 }
 
 async function main() {
+  if (process.argv[2] === "supervise") {
+    const { cloudSupervisorMain } = await import("./cloud-supervisor.mjs");
+    process.exitCode = await cloudSupervisorMain(process.argv.slice(3));
+    return;
+  }
   if (process.argv[2] === "repair-startup") {
     const { startupRepairMain } = await import("./startup-repair.mjs");
     process.exitCode = await startupRepairMain(process.argv.slice(3));

package/bin/windows-private-path.mjs

@@ -1,9 +1,10 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
+import { createConnection } from "node:net";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
 import { join, resolve } from "node:path";
 import { lstat } from "node:fs/promises";
 
-const execute = promisify(execFile);
 export function validateWindowsPrivateAcl(snapshot) {
   const sid = snapshot?.sid;
   if (typeof sid !== "string" || !/^S-1-(?:\d+-){1,14}\d+$/.test(sid))
@@ -54,36 +55,230 @@ export function validateWindowsPrivateAcl(snapshot) {
     throw new Error("The private Windows path or its parent can be replaced by another principal.");
 }
 
+// Keep the native process, never its results. Every request reads the current
+// file and all ancestor ACLs again, including after a permission change.
+const inspectionScript = (pipeName) => `$ErrorActionPreference='Stop'
+[Console]::Error.WriteLine('TOTEM_ACL_START')
+function Rules($acl) { @($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]) | ForEach-Object { @{sid=$_.IdentityReference.Value;rights=[int64]$_.FileSystemRights;type=$_.AccessControlType.ToString();inheritOnly=[bool]($_.PropagationFlags -band [Security.AccessControl.PropagationFlags]::InheritOnly)} }) }
+$security=[IO.Pipes.PipeSecurity]::new()
+$owner=[Security.Principal.WindowsIdentity]::GetCurrent().User
+$security.SetOwner($owner)
+$security.SetAccessRuleProtection($true,$false)
+$security.AddAccessRule([IO.Pipes.PipeAccessRule]::new($owner,[IO.Pipes.PipeAccessRights]::FullControl,[Security.AccessControl.AccessControlType]::Allow))
+$pipe=[IO.Pipes.NamedPipeServerStream]::new('${pipeName}',[IO.Pipes.PipeDirection]::InOut,1,[IO.Pipes.PipeTransmissionMode]::Byte,[IO.Pipes.PipeOptions]::None,4096,4096,$security)
+[Console]::Error.WriteLine('TOTEM_ACL_PIPE_READY')
+try {
+$pipe.WaitForConnection()
+[Console]::Error.WriteLine('TOTEM_ACL_CONNECTED')
+$hello=[Text.Encoding]::UTF8.GetBytes('{"id":0,"nonce":"'+$env:TOTEM_ACL_CHALLENGE+'"}'+"\`n")
+$pipe.Write($hello,0,$hello.Length)
+[Console]::Error.WriteLine('TOTEM_ACL_HELLO_SENT')
+[byte[]]$buffer=[Array]::CreateInstance([byte],4096)
+[Console]::Error.WriteLine('TOTEM_ACL_BUFFER_READY')
+$pending=''
+function Send-Frame($frame) {
+  $bytes=[Text.Encoding]::UTF8.GetBytes(($frame | ConvertTo-Json -Depth 9 -Compress)+"\`n")
+  $pipe.Write($bytes,0,$bytes.Length)
+}
+while ($true) {
+  while (($end=$pending.IndexOf("\`n")) -lt 0) {
+    [Console]::Error.WriteLine('TOTEM_ACL_READING')
+    $length=$pipe.Read($buffer,0,$buffer.Length)
+    if ($length -eq 0) { return }
+    [Console]::Error.WriteLine('TOTEM_ACL_FRAME_READ')
+    $pending += [Text.Encoding]::ASCII.GetString($buffer,0,$length)
+    if ($pending.Length -gt 65536) { throw 'ACL request too large' }
+  }
+  $line=$pending.Substring(0,$end)
+  $pending=$pending.Substring($end+1)
+  [Console]::Error.WriteLine('TOTEM_ACL_REQUEST_RECEIVED')
+  $request=$null
+  try {
+    $request=$line | ConvertFrom-Json
+    $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($request.path))
+    $sid=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+    $item=Get-Item -LiteralPath $path -Force
+    $acl=Get-Acl -LiteralPath $path
+    $parents=@(); $parent=Split-Path -LiteralPath $path
+    while ($parent) {
+      $p=Get-Item -LiteralPath $parent -Force
+      $parentAcl=Get-Acl -LiteralPath $parent
+      $parents+=@{owner=$parentAcl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($p.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $parentAcl)}
+      $next=Split-Path -LiteralPath $parent
+      if ($next -eq $parent) { break }; $parent=$next
+    }
+    $snapshot=@{sid=$sid;owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($item.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $acl);ancestors=$parents}
+     Send-Frame @{id=$request.id;snapshot=$snapshot}
+     [Console]::Error.WriteLine('TOTEM_ACL_RESULT_SENT')
+  } catch {
+     Send-Frame @{id=$request.id;error='ACL inspection failed'}
+  }
+}
+} finally { $pipe.Dispose() }
+`;
+
+export function createWindowsAclReader(options = {}) {
+  let worker,
+    nextId = 0;
+  const unavailable = () => new Error("The Windows access rules could not be verified.");
+  function stop(current) {
+    if (current.stopped) return;
+    current.stopped = true;
+    if (worker === current) worker = undefined;
+    clearTimeout(current.idle);
+    clearTimeout(current.reconnect);
+    for (const { timer, reject } of current.pending.values()) {
+      clearTimeout(timer);
+      reject(unavailable());
+    }
+    current.pending.clear();
+    current.socket?.destroy();
+    current.child?.kill();
+  }
+  function start() {
+    const environment = options.environment ?? process.env;
+    const systemRoot = options.systemRoot ?? environment.SystemRoot ?? environment.SYSTEMROOT;
+    if (!systemRoot) throw new Error("The Windows system directory could not be verified.");
+    const name = `totem-acl-${process.pid}-${randomUUID()}`;
+    const nonce = randomUUID();
+    const current = {
+      pending: new Map(),
+      buffer: "",
+      decoder: new StringDecoder("utf8"),
+      nonce,
+      stopped: false,
+      authenticated: false,
+    };
+    worker = current;
+    const child = (options.spawn ?? spawn)(
+      join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(inspectionScript(name), "utf16le").toString("base64"),
+      ],
+      {
+        // The encoded command uses a protected native pipe independently of stdin;
+        // no file paths or secrets are written to stdio.
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+        env: {
+          ...Object.fromEntries(
+            Object.entries(environment).filter(([name]) =>
+              /^(PATH|PATHEXT|COMSPEC|TEMP|TMP|USERPROFILE|HOMEDRIVE|HOMEPATH|APPDATA|LOCALAPPDATA|PROGRAMDATA|PROGRAMFILES|PROGRAMFILES\(X86\)|PSMODULEPATH|SYSTEMDRIVE|USERNAME|USERDOMAIN)$/i.test(
+                name,
+              ),
+            ),
+          ),
+          SystemRoot: systemRoot,
+          windir: systemRoot,
+          TOTEM_ACL_CHALLENGE: nonce,
+        },
+      },
+    );
+    current.child = child;
+    child.unref();
+    child.stderr?.unref?.();
+    let diagnostics = "";
+    child.stderr?.on("data", (chunk) => {
+      diagnostics = (diagnostics + chunk.toString()).slice(-4096);
+      for (const line of diagnostics.split(/\r?\n/).slice(0, -1))
+        if (/^TOTEM_ACL_[A-Z_]+$/.test(line)) options.onDiagnostic?.(line);
+      diagnostics = diagnostics.slice(diagnostics.lastIndexOf("\n") + 1);
+    });
+    child.on("error", () => stop(current));
+    child.on("close", () => stop(current));
+    const connect = () => {
+      if (current.stopped) return;
+      const socket = (options.createConnection ?? createConnection)({
+        path: "\\\\.\\pipe\\" + name,
+      });
+      current.socket = socket;
+      // Pending request timers keep the owner alive. Owner exit closes the pipe
+      // and the native reader exits; idle inspectors cannot prolong a CLI run.
+      socket.unref();
+      let retry = false;
+      socket.on("error", (error) => {
+        if (/^[A-Z_]{1,40}$/.test(error.code ?? "")) options.onDiagnostic?.(error.code);
+        if (!current.authenticated && error.code === "ENOENT") {
+          retry = true;
+          current.reconnect = setTimeout(connect, 25);
+          current.reconnect.unref();
+        } else stop(current);
+      });
+      socket.on("close", () => {
+        if (!retry) stop(current);
+      });
+      socket.on("data", (chunk) => {
+        if (current.stopped) return;
+        current.buffer += current.decoder.write(chunk);
+        if (Buffer.byteLength(current.buffer) > 262144) return stop(current);
+        let end;
+        while ((end = current.buffer.indexOf("\n")) >= 0) {
+          const line = current.buffer.slice(0, end).replace(/^\uFEFF/, "");
+          current.buffer = current.buffer.slice(end + 1);
+          let response;
+          try {
+            response = JSON.parse(line);
+          } catch {
+            return stop(current);
+          }
+          if (!current.authenticated) {
+            if (
+              response.id !== 0 ||
+              typeof response.nonce !== "string" ||
+              response.nonce.length !== nonce.length ||
+              !/^[a-f0-9-]{36}$/.test(response.nonce) ||
+              !timingSafeEqual(Buffer.from(response.nonce), Buffer.from(nonce))
+            )
+              return stop(current);
+            current.authenticated = true;
+            options.onDiagnostic?.("AUTHENTICATED");
+            for (const pending of current.pending.values()) socket.write(pending.request);
+            options.onDiagnostic?.("REQUEST_SENT");
+            continue;
+          }
+          const pending = current.pending.get(response.id);
+          if (!pending) return stop(current);
+          clearTimeout(pending.timer);
+          current.pending.delete(response.id);
+          options.onDiagnostic?.("RESULT_RECEIVED");
+          if (response.error || !response.snapshot) pending.reject(unavailable());
+          else pending.resolve(response.snapshot);
+        }
+        if (!current.pending.size) {
+          current.idle = setTimeout(() => stop(current), options.idleMs ?? 30000);
+          current.idle.unref();
+        }
+      });
+    };
+    connect();
+    return current;
+  }
+  return {
+    read(path) {
+      const encodedPath = Buffer.from(resolve(path), "utf8").toString("base64");
+      const current = worker ?? start();
+      clearTimeout(current.idle);
+      if (current.pending.size >= 1024) return Promise.reject(unavailable());
+      const id = ++nextId;
+      return new Promise((resolveRequest, reject) => {
+        const timer = setTimeout(() => stop(current), options.timeoutMs ?? 10000);
+        const request = JSON.stringify({ id, path: encodedPath }) + "\n";
+        current.pending.set(id, { resolve: resolveRequest, reject, timer, request });
+        if (current.authenticated) current.socket.write(request);
+      });
+    },
+    close() {
+      if (worker) stop(worker);
+    },
+  };
+}
+
+const reader = createWindowsAclReader();
 export async function assertWindowsPrivatePath(path) {
   if (process.platform !== "win32") return;
   await lstat(path); // Preserve ENOENT for callers that create a new private file.
-  const encoded = Buffer.from(resolve(path), "utf8").toString("base64");
-  const script = `$ErrorActionPreference='Stop'
-$path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))
-$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value
-function Rules($acl) { @($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]) | ForEach-Object { @{sid=$_.IdentityReference.Value;rights=[int64]$_.FileSystemRights;type=$_.AccessControlType.ToString();inheritOnly=[bool]($_.PropagationFlags -band [Security.AccessControl.PropagationFlags]::InheritOnly)} }) }
-$item=Get-Item -LiteralPath $path -Force
-$acl=Get-Acl -LiteralPath $path
-$parents=@(); $parent=Split-Path -LiteralPath $path
-while ($parent) {
-  $p=Get-Item -LiteralPath $parent -Force
-  $parentAcl=Get-Acl -LiteralPath $parent
-  $parents+=@{owner=$parentAcl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($p.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $parentAcl)}
-  $next=Split-Path -LiteralPath $parent
-  if ($next -eq $parent) { break }; $parent=$next
-}
-@{sid=$sid;owner=$acl.GetOwner([Security.Principal.SecurityIdentifier]).Value;reparse=[bool]($item.Attributes -band [IO.FileAttributes]::ReparsePoint);rules=@(Rules $acl);ancestors=$parents} | ConvertTo-Json -Depth 8 -Compress`;
-  const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
-  if (!systemRoot) throw new Error("The Windows system directory could not be verified.");
-  const { stdout } = await execute(
-    join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
-    [
-      "-NoProfile",
-      "-NonInteractive",
-      "-EncodedCommand",
-      Buffer.from(script, "utf16le").toString("base64"),
-    ],
-    { timeout: 10000, maxBuffer: 262144, windowsHide: true },
-  );
-  validateWindowsPrivateAcl(JSON.parse(stdout.replace(/^\uFEFF/, "")));
+  validateWindowsPrivateAcl(await reader.read(path));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.96",
+  "version": "0.1.115",
   "description": "Connect AI agents to Totem Network for discovery, messaging, and shared work.",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
   "homepage": "https://totemlayer.com",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/totemlayer/Totem.git"
+    "url": "git+https://github.com/linbrandon4/Totem.git"
   },
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {