tryharness 0.7.22 → 0.7.23

package/lib/cards.mjs

@@ -71,6 +71,8 @@ export function swarmCards(store, entries, { home } = {}) {
     work.set(row.agent, entry);
   }
   const seen = new Map(store.agentsSeen().map((row) => [row.agent, row.last_seen_at]));
+  // What its own sessions showed after its changes, from the relay's receipts (a store from before receipts has none).
+  const checks = store.receiptCounts?.() ?? {};
   return entries.map((entry) => {
     const roster = member(entry.id) ?? {};
     const done = work.get(entry.id) ?? { done: 0, failed: 0, minutes: [], working: 0, waiting: 0 };
@@ -79,7 +81,7 @@ export function swarmCards(store, entries, { home } = {}) {
       id: entry.id, name: roster.name ?? entry.id, about: roster.about ?? "", limits: roster.limits ?? null, where: roster.where ?? null,
       ...(roster.runs === "machine" ? { review: roster.review === true, model: modelLine(store, entry.id, home) } : {}),
       answers: answersFor(entry),
-      record: { done: done.done, failed: done.failed, medianMinutes: minutes === null ? null : Math.round(minutes * 10) / 10 },
+      record: { done: done.done, failed: done.failed, medianMinutes: minutes === null ? null : Math.round(minutes * 10) / 10, ...(checks[entry.id] ? { checks: checks[entry.id] } : {}) },
       working: done.working, waiting: done.waiting, lastSeen: seen.get(entry.id) ?? null, note: noteOf(store, entry.id),
       ...(entry.setup?.state ? { setup: String(entry.setup.state) } : {}),
     };
@@ -100,6 +102,8 @@ export function cardLine(card, now = Date.now()) {
   const { done, failed, medianMinutes } = card.record;
   // Work for an agent whose tasks live on Harness's server is not on this board, so none here says nothing about it.
   if (done || failed) parts.push(`On this board: ${done} done, ${failed} failed${medianMinutes === null ? "" : `; a median of ${span(medianMinutes)} from start to report`}.`);
+  const checks = card.record.checks;
+  if (checks) parts.push(`Its own sessions show its changes tested after the last edit ${checks.tested} of ${checks.tested + checks.untested + checks.failing} times${checks.failing ? ` (${checks.failing} with tests failing)` : ""}.`);
   else if (member(card.id)?.home === "machine") parts.push("Has finished no work on this board yet.");
   if (card.working || card.waiting) parts.push(`Now: ${card.working} running, ${card.waiting} waiting for it.`);
   // An agent that picks work up itself: when it last looked says whether it is around.

package/lib/context.mjs

@@ -0,0 +1,290 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { openAtlas, treeFiles, addFiles, embedMissing, searchFiles, ATLAS_VERSION } from "./atlas.mjs";
+import { readTrail, needs, trailFromTranscript } from "./trails.mjs";
+import { featureRows, swarmPrior, baselineScore, train, modelScore, recallAt, loadModel, saveModel, codeFiles } from "./learn.mjs";
+import { repositoryOf } from "./worktrees.mjs";
+import { createMediaIndex } from "./media.mjs";
+
+// The context engine. It keeps the atlas of the code the swarm works in, remembers what every coding session on this
+// computer needed (its trail: what it read before its first edit and what it edited, from any agent), and turns that
+// into a context pack for each brief: the files most likely needed, with the line to start at and why. Overnight, on
+// the charger, it retrains its small ranking model on the runs it has seen and keeps the new model only if it beats the
+// old one on the newest runs. Packs are leads for local agents; nothing here leaves the computer.
+
+const PACK_FILES = 8;
+const POOL = 60;
+const HISTORY_DAYS = 60;
+const REFRESH_MS = 15 * 60_000;
+const LEARN_EVERY_MS = 20 * 3_600_000;
+// Vectors of the pieces packs search stay in memory while packs are being made, and go after this long without one.
+const VECTORS_IDLE_MS = 5 * 60_000;
+const HELD_OUT_SHARE = 0.2;
+// A recording's minute or a screenshot joins a brief only this close to the request: on the authored meeting every right
+// answer scored 0.68 or more and no question about something never said passed 0.675 (eval media-search); 0.70 keeps a
+// margin and 16 of 20 right answers. An agent's own search_media has no floor.
+const MEDIA_FLOOR = 0.7;
+const MEDIA_IN_PACK = 2;
+const MIN_TRAINING_RUNS = 30;
+
+const git = (cwd, args) => { const out = spawnSync("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28 }); return out.status === 0 ? out.stdout : ""; };
+const commitBefore = (root, at) => git(root, ["rev-list", "-1", `--before=${new Date(at).toISOString()}`, "HEAD"]).trim() || null;
+// Files changed in the two weeks before a commit, by how often; kept per commit, since a commit's history is fixed.
+const recentByCommit = new Map();
+export function recentChanges(root, commit = "HEAD") {
+  const sha = git(root, ["rev-parse", commit]).trim();
+  if (recentByCommit.has(sha)) return recentByCommit.get(sha);
+  const counts = new Map();
+  const since = new Date((Number(git(root, ["show", "-s", "--format=%ct", sha]).trim()) - 14 * 86_400) * 1000).toISOString();
+  for (const file of git(root, ["log", `--since=${since}`, "--name-only", "--format=", sha]).split("\n")) if (file) counts.set(file, (counts.get(file) ?? 0) + 1);
+  if (recentByCommit.size > 500) recentByCommit.clear();
+  recentByCommit.set(sha, counts);
+  return counts;
+}
+const days = (ms) => Math.round(ms / 86_400_000);
+const AGENT_NAMES = { "claude-code": "Claude Code", codex: "Codex", pi: "Pi", opencode: "OpenCode" };
+
+/**
+ * Ranks a snapshot's files for a request with every signal the engine has: [{ path, best, score, x }] best first.
+ * history: earlier runs in this repository ({ at, edited, read }); model: the learned ranker or null for the default.
+ */
+export async function rankFiles({ atlas, inference, query, scope, history = [], at = Date.now(), recent = new Map(), model = null, vectors = null, lane = "handoff", wordLimit }) {
+  const candidates = await searchFiles(atlas, inference, query, scope, { vectors, lane, wordLimit });
+  const topWords = Math.max(...candidates.map((c) => c.lexical), 0) || 1;
+  const hybrid = (c) => c.dense + 0.25 * (c.lexical / topWords) + 0.2 * c.named;
+  const byHybrid = [...candidates].sort((a, b) => hybrid(b) - hybrid(a));
+  const prior = swarmPrior(history, at);
+  // No cross-encoder pass: on the owner's own sessions it moved recall by under one point (context-recall v3).
+  const byDense = [...candidates].sort((a, b) => b.dense - a.dense).slice(0, POOL).map((c) => c.path);
+  const byWords = [...candidates].sort((a, b) => b.lexical - a.lexical).slice(0, POOL).map((c) => c.path);
+  const pool = new Set([...byDense, ...byWords, ...byHybrid.slice(0, POOL).map((c) => c.path), ...candidates.filter((c) => c.named > 0).map((c) => c.path),
+    ...[...prior.edits.entries()].sort((a, b) => b[1] - a[1]).slice(0, POOL).map(([file]) => file)]);
+  const best = new Map(candidates.map((c) => [c.path, c.best]));
+  const scored = featureRows(candidates.filter((c) => pool.has(c.path)), { prior, recent })
+    .map((row) => ({ ...row, best: best.get(row.path), score: model ? modelScore(model, row.x) : baselineScore(row.x) }));
+  return scored.sort((a, b) => b.score - a.score);
+}
+
+export function createContextEngine({ store, inference, home, known, mediaFolders = () => [], mediaReady = () => false, log = () => {}, notify = () => {} }) {
+  const atlas = openAtlas(path.join(home, "atlas.db"));
+  // Recordings and screenshots in folders the person added (media.mjs), once the image and audio part is here.
+  const media = createMediaIndex({ atlas, inference, folders: mediaFolders, log });
+  const modelPath = path.join(home, "ranker.json");
+  let model = loadModel(modelPath);
+  let refreshing = null;
+  let timer = null;
+  const cached = new Map();
+  let dropCache = null;
+  /** The vectors for a scope's pieces, read from the atlas once and kept until packs stop for a while. */
+  const vectorsFor = (scope) => {
+    const wanted = new Set();
+    for (const row of scope) for (const hash of atlas.blob(row.blob) ?? []) if (!cached.has(hash)) wanted.add(hash);
+    if (wanted.size) for (const [hash, vector] of atlas.vectors(wanted, ATLAS_VERSION)) cached.set(hash, vector);
+    clearTimeout(dropCache);
+    dropCache = setTimeout(() => cached.clear(), VECTORS_IDLE_MS);
+    dropCache.unref?.();
+    return cached;
+  };
+
+  /** The repository a folder belongs to and where its files are (a worktree is read where it is, named as its repository). */
+  const placeOf = (folder) => {
+    const repo = repositoryOf(folder);
+    if (!repo) return null;
+    const common = git(repo.root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]).trim();
+    const root = common && path.basename(common) === ".git" ? path.dirname(common) : repo.root;
+    return { root, top: repo.root };
+  };
+
+  const roots = () => [...new Set(known().map((place) => placeOf(place.path)?.root).filter(Boolean))];
+
+  /** Brings one checkout's files into the atlas; returns its files. Pieces are embedded later on the background lane. */
+  const indexTree = (top, commit = null) => {
+    const rows = treeFiles(top, commit);
+    addFiles(atlas, top, rows);
+    return rows;
+  };
+
+  /** Records every coding session that ran in a known repository: what it was asked and what it needed. */
+  const recordRuns = async () => {
+    const rootList = roots();
+    const since = new Date(Date.now() - HISTORY_DAYS * 86_400_000).toISOString();
+    const trees = new Map();
+    let added = 0;
+    for (const session of store.sessionSources({ since })) {
+      const place = placeOf(session.cwd);
+      if (!place || !rootList.includes(place.root)) continue;
+      // A session whose source file the agent has since deleted is read from the relay's own copy, once.
+      let mtime = 0;
+      try { mtime = fs.statSync(session.source).mtimeMs; } catch {}
+      if (atlas.runSeen(session.agent, session.session_id) === mtime) continue;
+      const trail = mtime ? await readTrail(session.agent, session.source)
+        : trailFromTranscript(session.agent, store.sessionTranscript(session.agent, session.session_id), { cwd: session.cwd, startedAt: Date.parse(session.started_at) || null });
+      if (!trail?.brief || trail.startedAt === null) continue;
+      const commit = commitBefore(place.root, trail.startedAt);
+      if (!commit) continue;
+      if (!trees.has(commit)) trees.set(commit, new Set(treeFiles(place.root, commit).map((row) => row.path)));
+      const need = needs({ ...trail, cwd: trail.cwd && placeOf(trail.cwd)?.top === place.top ? path.join(place.root, path.relative(place.top, trail.cwd)) : trail.cwd }, place.root, trees.get(commit));
+      atlas.putRun({ agent: session.agent, sessionId: session.session_id, root: place.root, at: trail.startedAt, brief: trail.brief, edited: need.edited, read: need.read, before: need.beforeFirstEdit, sourceMtime: mtime });
+      added += 1;
+    }
+    return added;
+  };
+
+  const embedRuns = async (lane) => {
+    for (;;) {
+      const rows = atlas.runsToEmbed(ATLAS_VERSION, 16);
+      if (!rows.length) return;
+      const vectors = await inference.embed(rows.map((row) => ({ kind: "document", title: "none", text: row.brief })), { lane });
+      rows.forEach((row, i) => atlas.putRunVector(row.agent, row.session_id, ATLAS_VERSION, vectors[i]));
+    }
+  };
+
+  /** Keeps the atlas current: the known repositories' files, the runs, and every piece's vector, at background priority. */
+  const refresh = () => {
+    refreshing ||= (async () => {
+      const power = inference.power;
+      // A first pass over a repository waits for the charger; small catch-ups run on battery too unless it is low.
+      if (power.paused()) return { skipped: "power" };
+      const first = !atlas.roots().length;
+      if (first && !power.onCharger()) return { skipped: "waiting for the charger" };
+      let files = 0;
+      for (const root of roots()) {
+        const rows = indexTree(root);
+        atlas.setFiles(root, rows);
+        files += rows.length;
+      }
+      const runs = await recordRuns();
+      const pieces = await embedMissing(atlas, inference, { lane: "background" });
+      await embedRuns("background");
+      const recorded = mediaReady() && mediaFolders().length && power.onCharger() ? await media.refresh({ lane: "background" }) : null;
+      return { files, runs, pieces, ...(recorded ? { media: recorded } : {}) };
+    })().catch((error) => { log(`context engine: ${error.message}`); return { error: error.message }; }).finally(() => { refreshing = null; });
+    return refreshing;
+  };
+
+  const historyFor = (root) => atlas.runs(root).map((run) => ({ at: run.at, edited: run.edited, read: run.read }));
+
+  /**
+   * The context pack for a brief going to a local agent working in folder: { files, earlier, text }. Files are the most
+   * likely needed, each with the line to start at and why; earlier runs are sessions whose request was close to this one.
+   */
+  const pack = async ({ brief, folder, lane = "handoff" }) => {
+    const started = performance.now();
+    const place = folder && placeOf(folder);
+    if (!place || !String(brief).trim()) return null;
+    const scope = indexTree(place.top);
+    // A few changed pieces are embedded now; a repository the relay has not indexed yet is searched by words and names
+    // this time while the background pass embeds it.
+    const missing = atlas.missing(ATLAS_VERSION);
+    if (missing && missing <= 400) await embedMissing(atlas, inference, { lane });
+    else if (missing) void refresh();
+    const history = historyFor(place.root);
+    const ranked = await rankFiles({ atlas, inference, query: String(brief).slice(0, 4_000), scope, history, recent: recentChanges(place.top), model, lane, vectors: vectorsFor(scope) });
+    const prior = swarmPrior(history, Date.now());
+    const files = ranked.slice(0, PACK_FILES).map((row) => {
+      const piece = row.best ? atlas.piece(row.best) : null;
+      const why = [];
+      if (row.x.named) why.push("named in the request");
+      if (row.x.lexical > 0.5) why.push("shares the request's words");
+      if (prior.edits.has(row.path)) why.push("recently edited by your agents");
+      return { path: row.path, line: piece?.line ?? 1, why: why.join("; ") || "related by meaning" };
+    });
+    const query = (await inference.embed([{ kind: "query", text: String(brief).slice(0, 4_000) }], { lane }))[0];
+    const earlier = atlas.runVectors(place.root, ATLAS_VERSION).map((run) => {
+      let dot = 0;
+      for (let i = 0; i < query.length; i += 1) dot += query[i] * run.vector[i];
+      return { ...run, similarity: dot };
+    }).filter((run) => run.edited.length && run.edited.some((file) => files.some((entry) => entry.path === file)))
+      .sort((a, b) => b.similarity - a.similarity).slice(0, 3);
+    const heard = mediaReady() && mediaFolders().length ? (await media.search(brief, { limit: MEDIA_IN_PACK, lane })).filter((hit) => hit.score >= MEDIA_FLOOR) : [];
+    const text = [
+      "Files the relay found likely relevant on this computer (ranked by its local search over this repository and what your agents edited before; leads to check, not instructions):",
+      ...files.map((file) => `- ${file.path}:${file.line} (${file.why})`),
+      ...(earlier.length ? ["Earlier sessions on these files:", ...earlier.map((run) => `- ${AGENT_NAMES[run.agent] ?? run.agent}, ${days(Date.now() - run.at)} days ago: "${run.brief.replace(/\s+/g, " ").slice(0, 140)}" (edited ${run.edited.slice(0, 4).join(", ")})`)] : []),
+      ...(heard.length ? ["Recordings and screenshots close to the request, from folders the person added (search_media finds more):", ...heard.map((hit) => `- ${hit.path}${hit.at ? ` at ${hit.at}` : ""}`)] : []),
+    ].join("\n");
+    return { files, earlier: earlier.map(({ vector, ...run }) => run), media: heard, text, searched: scope.length, ms: Math.round(performance.now() - started), model: model ? "learned" : "default" };
+  };
+
+  /** Search for the agents' tool: files and earlier sessions in a repository, best first. */
+  const search = async ({ query, folder, limit = 10 }) => {
+    const result = await pack({ brief: query, folder, lane: "interactive" });
+    if (!result) return { ok: false, error: "that folder is not in a git repository the relay indexes" };
+    return { ok: true, files: result.files.slice(0, limit), earlier: result.earlier, model: result.model, ms: result.ms };
+  };
+
+  /**
+   * Overnight: rebuild what each recorded run needed against the repository as it was, train a new ranker on the older
+   * runs and keep it only if it ranks the newest runs' edited files better than the current one. Returns the report.
+   */
+  const learn = async ({ force = false } = {}) => {
+    const last = Number(atlas.meta("learned_at") || 0);
+    if (!force && (Date.now() - last < LEARN_EVERY_MS || !inference.power.onCharger() || inference.power.paused())) return null;
+    await refresh();
+    const report = { at: new Date().toISOString(), repositories: [] };
+    const rows = [];
+    for (const root of roots()) {
+      const runs = atlas.runs(root, Date.now() - HISTORY_DAYS * 86_400_000).filter((run) => run.edited.length);
+      if (!runs.length) continue;
+      const snapshots = new Map();
+      for (const run of runs) {
+        const commit = commitBefore(root, run.at);
+        if (!commit) continue;
+        if (!snapshots.has(commit)) snapshots.set(commit, indexTree(root, commit));
+        rows.push({ root, run, commit });
+      }
+      report.repositories.push({ root, runs: runs.length, snapshots: snapshots.size });
+    }
+    await embedMissing(atlas, inference, { lane: "background" });
+    rows.sort((a, b) => a.run.at - b.run.at);
+    if (rows.length < MIN_TRAINING_RUNS) { atlas.meta("learned_at", Date.now()); return { ...report, kept: false, why: `only ${rows.length} runs so far` }; }
+    const featured = [];
+    for (const { root, run, commit } of rows) {
+      const history = historyFor(root).filter((other) => other.at < run.at);
+      const ranked = await rankFiles({ atlas, inference, query: run.brief, scope: treeFiles(root, commit), history, at: run.at, recent: recentChanges(root, commit), model: null, lane: "background" });
+      featured.push({ run, ranked });
+    }
+    const cut = Math.floor(featured.length * (1 - HELD_OUT_SHARE));
+    const label = (run, row) => (codeFiles(run.edited).includes(row.path) ? 1 : 0);
+    const trainRows = featured.slice(0, cut).flatMap(({ run, ranked }) => ranked.map((row) => ({ x: row.x, y: label(run, row) })));
+    const candidate = train(trainRows);
+    const heldOut = featured.slice(cut).filter(({ run }) => codeFiles(run.edited).length);
+    const recall = (score) => heldOut.reduce((sum, { run, ranked }) => sum + recallAt([...ranked].sort((a, b) => score(b.x) - score(a.x)).map((row) => row.path), codeFiles(run.edited), 10), 0) / heldOut.length;
+    const result = { default: recall(baselineScore), current: model ? recall((x) => modelScore(model, x)) : null, candidate: recall((x) => modelScore(candidate, x)) };
+    const bar = Math.max(result.default, result.current ?? 0);
+    const kept = result.candidate > bar;
+    if (kept) {
+      // Retrained on every run before it ships; the held-out score is the one reported.
+      model = { ...train(featured.flatMap(({ run, ranked }) => ranked.map((row) => ({ x: row.x, y: label(run, row) })))), trainedAt: report.at, heldOut: result, runs: featured.length };
+      saveModel(modelPath, model);
+    }
+    atlas.meta("learned_at", Date.now());
+    const full = { ...report, runs: featured.length, heldOutRuns: heldOut.length, recallAt10: result, kept };
+    atlas.meta("last_learning", JSON.stringify(full));
+    if (kept) notify(`Learned from ${featured.length} runs overnight: the files your agents went on to change are now in their briefs' top ten ${Math.round(result.candidate * 100)}% of the time (was ${Math.round(bar * 100)}%).`);
+    return full;
+  };
+
+  return {
+    atlas,
+    /** A folder's files as the atlas holds them now ([{ path, blob }]), indexed first; [] outside a repository. */
+    scope: (folder) => { const place = folder && placeOf(folder); return place ? indexTree(place.top) : []; },
+    pack,
+    search,
+    /** Recordings' minutes and screenshots closest to a question, for an agent's search_media. */
+    searchMedia: (query, options) => media.search(query, options),
+    refreshMedia: () => media.refresh({ lane: "background" }),
+    refresh,
+    learn,
+    report: () => { try { return JSON.parse(atlas.meta("last_learning") || "null"); } catch { return null; } },
+    status: () => ({ roots: atlas.roots(), pieces: { waiting: atlas.missing(ATLAS_VERSION) }, media: media.status(), model: model ? { trainedAt: model.trainedAt, heldOut: model.heldOut, runs: model.runs } : null, device: inference.device() }),
+    start() {
+      const tick = () => { void refresh().then(() => learn()).catch((error) => log(`context engine: ${error.message}`)); };
+      setTimeout(tick, 60_000).unref?.();
+      timer = setInterval(tick, REFRESH_MS);
+      timer.unref?.();
+    },
+    stop() { clearInterval(timer); clearTimeout(dropCache); cached.clear(); atlas.close(); },
+  };
+}

package/lib/coordinator.mjs

@@ -37,6 +37,8 @@ function localDecision(agent, facts) {
       : { command: "claude", args: ["-p", prompt, "--output-format", "json", "--tools", ""] };
     let child;
     try { child = spawn(invocation.command, invocation.args, { cwd: os.tmpdir() }); } catch (error) { reject(error); return; }
+    // An agent that exits before reading the prompt breaks the pipe; its exit code rejects below.
+    child.stdin.on("error", () => {});
     child.stdin.end(invocation.stdin ?? "");
     let out = "";
     child.stdout.on("data", (chunk) => { out += chunk; });
@@ -58,7 +60,7 @@ function localDecision(agent, facts) {
   });
 }
 
-export function createCoordinator({ store, mode, askHarness, connected, serverHas, roster, handOn, localAgents, pauseGoal, notifyBoard, searchContext, log }) {
+export function createCoordinator({ store, mode, askHarness, connected, serverHas, roster, handOn, localAgents, pauseGoal, notifyBoard, searchContext, log, frame = () => null }) {
   const busy = new Set();
   const again = new Set();
   const stateOf = (goalId) => JSON.parse(store.meta(`coordinator:${goalId}`) || '{"lastSeenSeq":0,"rounds":0,"withoutProgress":0,"lastRoundAt":null,"lastError":null}');
@@ -76,7 +78,10 @@ export function createCoordinator({ store, mode, askHarness, connected, serverHa
     const waiting = runs.filter(waitsForWindow);
     // Every agent the person can ask, each with its card (cards.mjs); a coding agent only where the thread has a folder for it
     // to work in, and Harness not while its part here waits for a window.
-    const candidates = roster().filter((candidate) => (!CODING.has(candidate.id) || thread.goal.workspace) && !(candidate.id === "harness" && waiting.length));
+    // Each card's receipts go only to a Harness that takes them (the same release as frames); an older one would refuse the round.
+    const framesTaken = mode() === "local" || serverHas("swarm_frame");
+    const candidates = roster().filter((candidate) => (!CODING.has(candidate.id) || thread.goal.workspace) && !(candidate.id === "harness" && waiting.length))
+      .map((candidate) => (framesTaken || !candidate.record?.checks ? candidate : { ...candidate, record: { ...candidate.record, checks: undefined } }));
     // Earlier words close in meaning to the newest post that the transcript no longer carries, from this thread and the
     // person's sessions on this machine.
     const newest = posts.filter((post) => post.seq > state.lastSeenSeq).map((post) => post.text).join("\n").slice(0, 2_000);
@@ -89,7 +94,10 @@ export function createCoordinator({ store, mode, askHarness, connected, serverHa
         if (hit.excerpt) related.push({ source: `${nameOf(hit.agent)} session "${String(hit.title || "").slice(0, 120)}"`, text: String(hit.excerpt).slice(0, 4_000) });
       }
     }
+    // The thread's task frame (frames.mjs): each run's receipt, other threads in the repository, its state.
+    const framed = frame(thread.id);
     return {
+      ...(framed ? { frame: framed } : {}),
       thread: { id: thread.id, title: thread.objective, folder: thread.goal.workspace, agents: thread.goal.team.filter((agent) => agent !== thread.goal.facilitator) },
       transcript, lastSeenSeq: state.lastSeenSeq, candidates,
       progress: { runsFinished, newResults, stillRunning: runs.filter(going).length, roundsWithoutProgress: state.withoutProgress, failedJobs,