@volter/supercode-teams 0.3.121 → 0.3.123

package/bin/teams.mjs

@@ -187,7 +187,12 @@ async function main() {
         process.on('SIGTERM', stop);
         return;
       }
-      if (sub === 'status') { out(readJson(p.machine, { running: false })); return; }
+      if (sub === 'status') {
+        // and every supercode process here still running a release an install replaced (t_8e109edc)
+        let stale_releases = null;
+        try { stale_releases = await (await import('@volter/supercode-health/drift')).staleSupercode(); } catch { /* not read */ }
+        out({ ...readJson(p.machine, { running: false }), stale_releases }); return;
+      }
       // `machine restart [--machine M] [--reason text]`: the daemon (this one, or M's through the server) restarts under its service.
       if (sub === 'restart') return withNode(async (rpc) => out(await rpc.call('machine.restart', { reason: flags.reason ? String(flags.reason) : null })));
       die('machine start|status|restart');

package/bin/workspace.mjs

@@ -2,9 +2,9 @@
 import { StringDecoder } from 'node:string_decoder';
 import { hostname } from 'node:os';
 import { agentSessionHint } from './workspace/agent-session.mjs';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, readFileSync, realpathSync, rmSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
@@ -1119,6 +1119,7 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
       if (!flags.json) {
         process.stdout.write(`Connected ${saved.machine.name} to team ${context.team_name ?? context.team_id}; it stays connected (a ${service.kind ?? 'background'} service).\n`);
         for (const line of service.message_tools ?? []) process.stdout.write(`  ${line}\n`);
+        for (const line of await releaseSkills()) process.stdout.write(`  ${line}\n`);
         return;
       }
       return output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, service, ...(addedRule ? { rule: addedRule } : {}) } });
@@ -1486,3 +1487,17 @@ function stampStderr() {
   };
   process.stderr.__stamped = true;
 }
+
+/**
+ * The skills of the release this Teams package belongs to (`@volter/supercode`'s lib/skills.mjs, the package that
+ * holds it), put into every harness here: a machine connected to a team has agents that know supercode
+ * (t_266912ff). A Teams package run from a checkout or installed alone has no release beside it, and installs none.
+ */
+async function releaseSkills() {
+  const release = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
+  try {
+    if (JSON.parse(readFileSync(join(release, 'package.json'), 'utf8')).name !== '@volter/supercode') return [];
+    const { installSkills } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    return installSkills();
+  } catch { return []; }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.121",
+  "version": "0.3.123",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/worker/index.mjs

@@ -143,15 +143,42 @@ export class TeamsServer extends DurableObject {
   }
 }
 
+/** What the Durable Object's runtime said of a failed call (its error's own flags), for the log and the answer. */
+const objectFailure = (error) => ({
+  name: String(error?.name ?? 'Error'),
+  message: String(error?.message ?? error).slice(0, 200),
+  retryable: error?.retryable === true,
+  overloaded: error?.overloaded === true,
+  remote: error?.remote === true,
+  reset: error?.durableObjectReset === true,
+});
+
 export default {
   async fetch(request, env) {
-    try { return await env.TEAMS_SERVER.get(env.TEAMS_SERVER.idFromName('server')).fetch(request); }
+    const repeatable = request.method === 'GET' || request.method === 'HEAD';
+    const call = () => env.TEAMS_SERVER.get(env.TEAMS_SERVER.idFromName('server')).fetch(repeatable ? request.clone() : request);
+    // A request safe to repeat (a read, or a link's WebSocket upgrade: every machine's connection) is tried once more
+    // when the runtime says the failure is retryable and the object is not overloaded: a reset object (its code
+    // updated, or evicted and restarted) answers the second call. Fleet-wide 503s for minutes with no deploy behind
+    // them (2026-10-06, 14:04Z and 18:41-18:44Z) dropped every machine's link; what the runtime said of them was only
+    // in the log, which now says it in one JSON line and the answer names it.
+    let first = null;
+    try { return await call(); }
     catch (error) {
-      // Failures before the HTTP handler (object initialization, migrations or
-      // storage) otherwise become a platform HTML page, not our API contract.
-      const requestId = crypto.randomUUID();
-      console.error(`Teams request ${requestId} failed before response: ${error.message}`);
-      return Response.json({ version: 1, error: { code: 'unavailable', message: 'Teams server is temporarily unavailable', request_id: requestId, retryable: true } }, { status: 503, headers: { 'Retry-After': '5', 'X-Request-ID': requestId } });
+      first = objectFailure(error);
+      if (!(repeatable && first.retryable && !first.overloaded)) return unavailable(first, null);
     }
+    try { return await call(); }
+    catch (error) { return unavailable(objectFailure(error), first); }
   },
 };
+
+/** Failures before the HTTP handler (object initialization, migrations, storage, a reset) as our API contract, not a
+ *  platform HTML page. The answer goes to callers not yet authenticated, so it names only the error's kind and the
+ *  runtime's flags; its message (storage or SQL text, internal paths) is in the log line its request id leads to. */
+function unavailable(failure, retried) {
+  const requestId = crypto.randomUUID();
+  console.error(JSON.stringify({ event: 'teams_unavailable', request_id: requestId, failure, ...(retried ? { first: retried } : {}) }));
+  const cause = `${failure.name}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
+  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: failure.name, retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
+}