totemlayer 0.1.77 → 0.1.92

package/bin/setup-receipts.mjs

@@ -64,15 +64,18 @@ export async function observeSetupDispatch({ directory, identity, sessionId, kin
     !text.includes(`Totem setup test ${request.nonce}`)
   )
     return;
-  const previous = await read(directory, `${kind}-dispatch`);
-  if (previous && previous.id !== id) return;
-  await privateWrite(path(directory, `${kind}-dispatch`), {
+  const name = `${kind}-dispatch-${id}`;
+  if (await read(directory, name)) return;
+  const dispatch = {
     version: 1,
     binding: request.binding,
     id,
     sessionId,
     dispatchedAt: Date.now(),
-  });
+  };
+  await privateWrite(path(directory, name), dispatch);
+  if (!(await read(directory, `${kind}-dispatch`)))
+    await privateWrite(path(directory, `${kind}-dispatch`), dispatch);
 }
 
 export async function recordSetupPeerReply({
@@ -97,7 +100,9 @@ export async function recordSetupPeerReply({
     !message.content?.text?.includes(`Totem setup test ${request.nonce}`)
   )
     return;
-  const dispatch = await read(profile.stateDirectory, "peer-dispatch");
+  const dispatch =
+    (await read(profile.stateDirectory, `peer-dispatch-${message.id}`)) ??
+    (await read(profile.stateDirectory, "peer-dispatch"));
   if (dispatch?.id !== message.id || dispatch.binding !== request.binding) return;
   const receivedAt = Date.parse(message.createdAt);
   if (!Number.isFinite(receivedAt) || receivedAt < request.issuedAt) return;
@@ -117,14 +122,24 @@ export async function recordSetupPeerReply({
   }
   if (cursor || replies.length !== 1 || replies[0].id !== reply.id) return;
   const acknowledged = await client.messages.get(message.id);
-  if (acknowledged.state !== "acknowledged") return;
+  const repliedAt = Date.parse(reply.createdAt);
+  const acknowledgedAt = Date.parse(acknowledged.readAt);
+  if (
+    acknowledged.id !== message.id ||
+    !["acknowledged", "responded"].includes(acknowledged.state) ||
+    !Number.isFinite(repliedAt) ||
+    !Number.isFinite(acknowledgedAt) ||
+    acknowledgedAt < repliedAt
+  )
+    return;
   await privateWrite(path(profile.stateDirectory, "peer"), {
     binding: request.binding,
     nativeSessionId: sessionId,
     messageId: message.id,
     replyId: reply.id,
     receivedAt,
-    repliedAt: Date.now(),
+    repliedAt,
+    acknowledgedAt,
     correlated: true,
     exactlyOneReply: true,
     acknowledgedAfterReply: true,
@@ -143,6 +158,7 @@ export async function recordSetupOwnerChat({
   text,
   sessionId,
   leaseRenewed,
+  client,
 }) {
   const request = await read(profile.stateDirectory, "request");
   if (!request || request.credentialFingerprint !== (await credentialFingerprint(profile))) return;
@@ -153,12 +169,41 @@ export async function recordSetupOwnerChat({
     !uuid(saved.chatId) ||
     !uuid(result?.event?.id) ||
     result.run?.state !== "completed" ||
-    result.event.chatId !== saved.chatId ||
+    result.run.id !== commandId ||
+    result.run.commandEventId !== saved.commandEventId ||
+    result.event.runId !== commandId ||
+    result.event.actor !== "agent" ||
     leaseRenewed !== true
   )
     return;
-  const dispatch = await read(profile.stateDirectory, "ownerChat-dispatch");
+  const dispatch =
+    (await read(profile.stateDirectory, `ownerChat-dispatch-${commandId}`)) ??
+    (await read(profile.stateDirectory, "ownerChat-dispatch"));
   if (dispatch?.id !== commandId || dispatch.binding !== request.binding) return;
+  let cursor = "0",
+    completedInOriginalChat = false;
+  for (let page = 0; page < 100; page++) {
+    const detail = await client.chats.get(saved.chatId, {
+      limit: 100,
+      ...(cursor ? { cursor } : {}),
+    });
+    if (detail.chat.id !== saved.chatId) return;
+    const event = detail.events.find((item) => item.id === result.event.id);
+    const run = detail.runs.find((item) => item.id === commandId);
+    if (
+      event?.actor === "agent" &&
+      event.runId === commandId &&
+      event.text === result.event.text &&
+      run?.state === "completed" &&
+      run.commandEventId === saved.commandEventId
+    ) {
+      completedInOriginalChat = true;
+      break;
+    }
+    if (!detail.hasMore || !detail.nextCursor || detail.nextCursor === cursor) return;
+    cursor = detail.nextCursor;
+  }
+  if (!completedInOriginalChat) return;
   await privateWrite(path(profile.stateDirectory, "ownerChat"), {
     binding: request.binding,
     commandId,

package/bin/startup-diagnostics.mjs

@@ -4,6 +4,20 @@ 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 = {
+  STARTUP_CONFLICT: [
+    "The existing startup task or shortcut uses a different command.",
+    "Inspect the current-user Windows startup task with totem repair-startup. Apply only its reviewed task digest; preserve disabled startup and verify receiving separately.",
+    false,
+  ],
+  STARTUP_DISABLED: [
+    "The owner disabled automatic startup on this host.",
+    "Keep receiving paused until the owner explicitly enables startup through this host's controls.",
+    false,
+  ],
+  STARTUP_REGISTRATION_FAILED: [
+    "The host could not verify registration of its startup entry.",
+    "Inspect this host's current-user startup permissions and service manager, then retry once after repair.",
+  ],
   LISTENER_STARTUP_UNAVAILABLE: [
     "The host has no verified enabled persistent listener service.",
     "Restore the host's supported startup service, then rerun setup. A temporary background process is not a complete installation.",

package/bin/startup-repair.mjs

@@ -0,0 +1,177 @@
+import { execFile } from "node:child_process";
+import { promisify, parseArgs } from "node:util";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  runtimeRoot,
+  privateDirectory,
+  privateRead,
+  ensureInstalledRuntime,
+} from "./runtime-installation.mjs";
+import { powershellInvocation } from "./platform-client.mjs";
+
+const execute = promisify(execFile);
+const literal = (value) => `'${String(value).replaceAll("'", "''")}'`;
+
+/** Explicit repair of one owner-reviewed task. Passive MCP startup never invokes this. */
+export async function repairWindowsStartup(environment = process.env, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32")
+    throw Object.assign(new Error("Run this repair on the Windows receiver host."), {
+      code: "STARTUP_REPAIR_UNSUPPORTED",
+    });
+  const digest = options.expectedTaskSha256 ?? "";
+  if (digest && !/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid task digest.");
+  const root = runtimeRoot(environment),
+    directory = join(root, "runtime");
+  const current = await privateRead(join(directory, "current.json"));
+  if (!/^\d+\.\d+\.\d+$/.test(current.version)) throw new Error("Invalid installed runtime.");
+  const suffix =
+    root === resolve(join(homedir(), ".totem"))
+      ? ""
+      : `.${createHash("sha256").update(root).digest("hex").slice(0, 12)}`;
+  const task = `TotemRuntime${suffix}`;
+  const backups = join(directory, "startup-backups");
+  if (digest) await privateDirectory(backups);
+  const script = `
+$ErrorActionPreference='Stop'
+$task=${literal(task)};$expected=${literal(digest)};$node=${literal(process.execPath)}
+$arguments=${literal('"' + join(directory, "supervisor.mjs") + '"')}
+$backupDirectory=${literal(backups)}
+function Hash($text) {
+  $sha=[Security.Cryptography.SHA256]::Create()
+  try { -join ($sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($text))|ForEach-Object {$_.ToString('x2')}) } finally { $sha.Dispose() }
+}
+function Owned($entry) {
+  $user=$entry.Principal.UserId
+  try {
+    $sid=if($user -like 'S-1-*'){[Security.Principal.SecurityIdentifier]::new($user)}else{[Security.Principal.NTAccount]::new($user).Translate([Security.Principal.SecurityIdentifier])}
+    $sid.Value -eq [Security.Principal.WindowsIdentity]::GetCurrent().User.Value -and [string]$entry.Principal.RunLevel -in @('Limited','0') -and [string]$entry.Principal.LogonType -in @('Interactive','InteractiveToken','3')
+  } catch { $false }
+}
+try {
+  $old=Get-ScheduledTask -TaskName $task -TaskPath '\\'
+  if(!(Owned $old)){throw 'STARTUP_OWNER_MISMATCH'}
+  if($old.State -eq 'Disabled' -or !$old.Settings.Enabled){throw 'STARTUP_DISABLED'}
+  if($old.Actions.Count -ne 1){throw 'STARTUP_CONFLICT'}
+  foreach($hive in @('HKCU:','HKLM:')) {
+    $key=$hive+'\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StartupApproved\\StartupFolder'
+    if(Test-Path -LiteralPath $key) {
+      $approval=(Get-Item -LiteralPath $key).GetValue($task+'.lnk',$null)
+      if($null -ne $approval -and ($approval.Length -lt 1 -or $approval[0] -notin @(2,6))){throw 'STARTUP_DISABLED'}
+    }
+  }
+  $xml=Export-ScheduledTask -TaskName $task -TaskPath '\\'
+  $hash=Hash $xml
+  $same=$old.Actions[0].Execute -eq $node -and $old.Actions[0].Arguments -eq $arguments
+  if(!$expected){@{state=if($same){'current'}else{'plan'};task=$task;taskSha256=$hash;version=${literal(current.version)};currentCommandType=[IO.Path]::GetFileName($old.Actions[0].Execute);proposedCommandType='node';changesProfiles=$false;changesPermissions=$false;requiresRestart=$true;receivingVerified=$false}|ConvertTo-Json -Compress;exit 0}
+  if($hash -ne $expected){throw 'STARTUP_PLAN_STALE'}
+  if($same){@{state='current';task=$task;version=${literal(current.version)};receivingVerified=$false}|ConvertTo-Json -Compress;exit 0}
+  $backup=Join-Path $backupDirectory ($hash+'.xml')
+  if(Test-Path -LiteralPath $backup) {
+    $file=Get-Item -LiteralPath $backup
+    if($file.PSIsContainer -or ($file.Attributes -band [IO.FileAttributes]::ReparsePoint) -or (Hash ([IO.File]::ReadAllText($backup))) -ne $hash){throw 'STARTUP_BACKUP_CONFLICT'}
+  } else {
+    $stream=[IO.File]::Open($backup,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::None)
+    try {$bytes=[Text.Encoding]::UTF8.GetBytes($xml);$stream.Write($bytes,0,$bytes.Length);$stream.Flush()}finally{$stream.Dispose()}
+  }
+  if((Hash (Export-ScheduledTask -TaskName $task -TaskPath '\\')) -ne $hash){throw 'STARTUP_PLAN_STALE'}
+  $wasRunning=$old.State -eq 'Running'
+  $changed=$false
+  try {
+    Stop-ScheduledTask -TaskName $task -TaskPath '\\'
+    $stopped=Get-ScheduledTask -TaskName $task -TaskPath '\\'
+    if($stopped.State -eq 'Running' -or $stopped.State -eq 'Disabled'){throw 'STARTUP_STOP_UNVERIFIED'}
+    if((Hash (Export-ScheduledTask -TaskName $task -TaskPath '\\')) -ne $hash){throw 'STARTUP_PLAN_STALE'}
+    $action=New-ScheduledTaskAction -Execute $node -Argument $arguments
+    $changed=$true
+    Set-ScheduledTask -TaskName $task -TaskPath '\\' -Action $action|Out-Null
+    $saved=Get-ScheduledTask -TaskName $task -TaskPath '\\'
+    if(!(Owned $saved) -or $saved.State -eq 'Disabled' -or $saved.Actions.Count -ne 1 -or $saved.Actions[0].Execute -ne $node -or $saved.Actions[0].Arguments -ne $arguments){throw 'STARTUP_REPAIR_UNVERIFIED'}
+    Start-ScheduledTask -TaskName $task -TaskPath '\\'
+    @{state='repaired';task=$task;version=${literal(current.version)};backupSha256=$hash;receivingVerified=$false}|ConvertTo-Json -Compress
+  } catch {
+    if(!$changed){
+      if($wasRunning -and (Hash (Export-ScheduledTask -TaskName $task -TaskPath '\\')) -eq $hash){Start-ScheduledTask -TaskName $task -TaskPath '\\'}
+      throw 'STARTUP_REPAIR_FAILED'
+    }
+    try {
+      Stop-ScheduledTask -TaskName $task -TaskPath '\\' -ErrorAction SilentlyContinue
+      Register-ScheduledTask -TaskName $task -TaskPath '\\' -Xml $xml -Force|Out-Null
+      if((Hash (Export-ScheduledTask -TaskName $task -TaskPath '\\')) -ne $hash){throw 'Rollback did not match'}
+      if($wasRunning){Start-ScheduledTask -TaskName $task -TaskPath '\\'}
+    } catch {throw 'STARTUP_ROLLBACK_FAILED'}
+    throw 'STARTUP_REPAIR_ROLLED_BACK'
+  }
+} catch {
+  $code=[string]$_.Exception.Message
+  if($code -notmatch '^STARTUP_[A-Z_]+$'){$code='STARTUP_REPAIR_FAILED'}
+  @{state='blocked';code=$code;receivingVerified=$false}|ConvertTo-Json -Compress
+}
+`;
+  const invocation = powershellInvocation(script, environment);
+  const result = await (options.execute ?? execute)(invocation.command, invocation.args, {
+    timeout: 30000,
+    maxBuffer: 8192,
+    windowsHide: true,
+  });
+  const receipt = JSON.parse(result.stdout.trim());
+  if (
+    !["plan", "current", "repaired", "blocked"].includes(receipt.state) ||
+    (receipt.state === "plan" && !/^[a-f0-9]{64}$/.test(receipt.taskSha256 ?? "")) ||
+    (receipt.state === "repaired" && receipt.backupSha256 !== digest)
+  )
+    throw new Error("Invalid startup repair receipt.");
+  return receipt;
+}
+
+export async function startupRepairMain(args, options = {}) {
+  const stdout = options.stdout ?? process.stdout;
+  try {
+    const { values } = parseArgs({
+      args,
+      allowPositionals: false,
+      options: {
+        help: { type: "boolean", short: "h" },
+        "expected-task-sha256": { type: "string" },
+        json: { type: "boolean" },
+      },
+    });
+    if (values.help) {
+      stdout.write(
+        "totem repair-startup [--expected-task-sha256 HEX] [--json]\nInspect the current-user Windows startup task. Supply its inspected SHA-256 to migrate only that task with a local backup and rollback. Profiles and pauses are preserved; receiving must be verified separately.\n",
+      );
+      return 0;
+    }
+    if (values["expected-task-sha256"]) {
+      if (!/^[a-f0-9]{64}$/.test(values["expected-task-sha256"]))
+        throw new Error("Invalid task digest.");
+      const plan = await repairWindowsStartup(options.env ?? process.env, options);
+      if (
+        !["plan", "current"].includes(plan.state) ||
+        plan.taskSha256 !== values["expected-task-sha256"]
+      ) {
+        stdout.write(
+          JSON.stringify({
+            state: "blocked",
+            code: plan.code ?? "STARTUP_PLAN_STALE",
+            receivingVerified: false,
+          }) + "\n",
+        );
+        return 1;
+      }
+      await (options.ensureRuntime ?? ensureInstalledRuntime)(options.env ?? process.env);
+    }
+    const result = await repairWindowsStartup(options.env ?? process.env, {
+      ...options,
+      expectedTaskSha256: values["expected-task-sha256"],
+    });
+    stdout.write(JSON.stringify(result) + "\n");
+    return result.state === "blocked" ? 1 : 0;
+  } catch (error) {
+    stdout.write(
+      JSON.stringify({ state: "blocked", code: error.code ?? "STARTUP_REPAIR_FAILED" }) + "\n",
+    );
+    return 1;
+  }
+}

package/bin/strict-codex-adapter.mjs

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
 import { opendir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
+import { createInterface } from "node:readline";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -90,28 +92,71 @@ export function createStrictCodexAdapter(flags, options = {}) {
       rpc = (options.connectHarness ?? connectCodexHarness)(inherited);
       await rpc.initialize();
     }
-    // Resuming with no overrides reads the persisted model and policy. No turn starts.
-    const current = await rpc.request("thread/resume", { threadId });
+    // Reading avoids acquiring the active chat's writer or changing its settings.
+    const current = await rpc.request("thread/read", { threadId });
+    const thread = current?.thread;
+    if (thread?.id !== threadId || thread.ephemeral !== false || thread.archived)
+      fail("EXACT_NATIVE_SESSION_REQUIRED");
     if (
-      current?.thread?.id !== threadId ||
-      current.thread.ephemeral !== false ||
-      current.thread.archived
+      !thread.model ||
+      thread.model === "default" ||
+      (flags.model && thread.model !== flags.model)
     )
-      fail("EXACT_NATIVE_SESSION_REQUIRED");
-    if (!current.model || (flags.model && current.model !== flags.model))
+      fail("CURRENT_MODEL_UNVERIFIED");
+    // Codex returns the native rollout path; permission settings are not in thread/read.
+    if (!thread.path || !isAbsolute(thread.path)) fail("CURRENT_SESSION_SETTINGS_UNVERIFIED");
+    let metadata,
+      settings,
+      partialRecord = false;
+    const input = createReadStream(thread.path, { encoding: "utf8" });
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (partialRecord) fail("CURRENT_SESSION_SETTINGS_UNVERIFIED");
+        let record;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          // The native writer may still be appending its final JSONL record.
+          if (line.endsWith("}")) fail("CURRENT_SESSION_SETTINGS_UNVERIFIED");
+          partialRecord = true;
+          continue;
+        }
+        if (record.type === "session_meta") metadata = record.payload;
+        if (record.type === "turn_context") settings = record.payload;
+      }
+    } catch {
+      fail("CURRENT_SESSION_SETTINGS_UNVERIFIED");
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+    if (
+      metadata?.id !== threadId ||
+      metadata.model_provider !== thread.modelProvider ||
+      !settings?.turn_id ||
+      settings.cwd !== thread.cwd ||
+      !settings.approval_policy ||
+      !settings.sandbox_policy?.type
+    )
+      fail("CURRENT_SESSION_SETTINGS_UNVERIFIED");
+    if (settings.model !== thread.model || settings.effort !== thread.reasoningEffort)
       fail("CURRENT_MODEL_UNVERIFIED");
     return {
       name: "codex",
-      model: current.model,
+      model: thread.model,
       sessionId: threadId,
       modelVerified: true,
       policyDigest: sha([
-        current.modelProvider,
-        current.approvalPolicy,
-        current.sandbox,
-        current.permissionProfile,
-        current.reasoningEffort,
-        current.serviceTier,
+        thread.modelProvider,
+        settings.approval_policy,
+        settings.approvals_reviewer,
+        settings.sandbox_policy,
+        settings.permission_profile,
+        settings.active_permission_profile,
+        settings.disabled_plugin_ids,
+        settings.effort,
+        settings.service_tier,
       ]),
     };
   }
@@ -354,11 +399,14 @@ export function createStrictCodexAdapter(flags, options = {}) {
     },
     async readReceiver(context) {
       let current;
-      for (let attempt = 0; attempt < 16; attempt++) {
-        current = await readAgentRuntimeStatus(profile);
-        if (Number.isFinite(current.measuredCheckSeconds) || !current.running) break;
+      const deadline = Date.now() + (flags.waitSeconds ?? 1200) * 1000;
+      do {
+        current = await (options.readStatus ?? readAgentRuntimeStatus)(profile);
+        if (Number.isFinite(current.measuredCheckSeconds) && current.listenerReady) break;
+        if (!(await automaticEnabled(profile))) fail("RECEIVER_INTENTIONALLY_PAUSED");
+        if (Date.now() >= deadline) break;
         await pause(1000);
-      }
+      } while (true);
       return {
         binding: context.binding,
         count: current.running ? 1 : 0,
@@ -368,7 +416,7 @@ export function createStrictCodexAdapter(flags, options = {}) {
         measuredCheckSeconds: current.measuredCheckSeconds,
         independentOfModel: true,
         silentWhenIdle: true,
-        bothQueues: true,
+        bothQueues: !identity.listenerConnectionId,
         privateState: true,
         startupEnabled: activation?.persistent === true,
         restartOnFailure: activation?.persistent === true,
@@ -396,7 +444,8 @@ export function createStrictCodexAdapter(flags, options = {}) {
       await privateWrite(join(profile.stateDirectory, "runner", `${current.runId}.stop`), {
         runId: current.runId,
       });
-      for (let attempt = 0; attempt < 120; attempt++) {
+      const deadline = Date.now() + (flags.waitSeconds ?? 1200) * 1000;
+      do {
         if (!(await automaticEnabled(profile))) fail("RECEIVER_INTENTIONALLY_PAUSED");
         const after = await readAgentRuntimeStatus(profile);
         if (after.runId !== current.runId && after.ready && after.listenerReady) {
@@ -414,8 +463,9 @@ export function createStrictCodexAdapter(flags, options = {}) {
           await privateWrite(file, receipt);
           return receipt;
         }
+        if (Date.now() >= deadline) break;
         await pause(1000);
-      }
+      } while (true);
       return { binding: context.binding, newRunVerified: false };
     },
     async requestTests(context) {

package/bin/strict-setup-jobs.mjs

@@ -9,7 +9,7 @@ import {
   installRuntimeService,
   runtimeRoot,
 } from "./runtime-installation.mjs";
-import { acquireSupervisorLock, processIdentity } from "./automatic-runtime.mjs";
+import { acquireSupervisorLock, processIdentity } from "./runtime-lock.mjs";
 
 const valid = (id) => typeof id === "string" && /^[a-f0-9]{64}$/.test(id);
 const missing = async (promise) =>
@@ -93,10 +93,18 @@ export async function scheduleStrictSetup(flags, host, env = process.env, option
     throw Object.assign(new Error(), { code: "SETUP_BINDING_CHANGED" });
   const job = previous ?? { version: 1, id, flags: selected };
   if (!validJob(job)) throw Object.assign(new Error(), { code: "SETUP_BINDING_UNVERIFIED" });
+  const status = await missing(privateRead(join(path, "status.json")));
+  const recheck =
+    status?.state === "blocked" &&
+    [
+      "RECEIVER_INTERVAL_UNVERIFIED",
+      "RECEIVER_CAPABILITY_INCOMPLETE",
+      "RECOVERY_UNVERIFIED",
+    ].includes(status.code);
+  if (status?.state === "blocked" && !recheck) return status;
   const runtime = await (options.ensureRuntime ?? ensureInstalledRuntime)(env);
   if (!previous) await privateWrite(join(path, "job.json"), job);
-  const status = await missing(privateRead(join(path, "status.json")));
-  if (status?.state === "complete")
+  if (status?.state === "complete" || recheck)
     await privateWrite(join(path, "status.json"), {
       state: "checking",
       complete: false,

package/bin/totem.mjs

@@ -249,6 +249,7 @@ Connect once and receive messages and approved Mission work
   totem setup
   totem status
   totem diagnose [--profile NAME] [--fresh] [--json]
+  totem repair-startup [--expected-task-sha256 HEX] [--json]
   totem start --background
   totem stop
 
@@ -1754,6 +1755,11 @@ async function runRfq(options, baseUrl) {
 }
 
 async function main() {
+  if (process.argv[2] === "repair-startup") {
+    const { startupRepairMain } = await import("./startup-repair.mjs");
+    process.exitCode = await startupRepairMain(process.argv.slice(3));
+    return;
+  }
   if (process.argv[2] === "install-worker") {
     const { strictSetupWorkerMain } = await import("./strict-setup-jobs.mjs");
     process.exitCode = await strictSetupWorkerMain(process.argv[3]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "totemlayer",
-  "version": "0.1.77",
+  "version": "0.1.92",
   "description": "Connect AI agents to Totem Network for discovery, messaging, and shared work.",
   "type": "module",
   "bin": {
@@ -32,6 +32,10 @@
     "authorization"
   ],
   "homepage": "https://totemlayer.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/totemlayer/Totem.git"
+  },
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {
     "access": "public",