flowviant 0.78.0 → 0.79.0

package/README.md

@@ -47,7 +47,11 @@ Launch with `@latest` so each start pulls the newest published version — a bar
 
 Each tab in the Workbench is a persistent Claude session with its own worktree, and it stays where you left it — the branch outlives the tab. The daemon runs each turn in event mode and relays what the CLI is printing (thinking, reads, greps, commands) back to the tab, reports the worktree's branch and diffstat after every turn, and fetches a commit's patch when you click a sha in the app.
 
-Nothing starts work except you opening a tab and typing in it.
+Nothing starts a session except you opening a tab and typing in it.
+
+## Agents
+
+Press **Deploy** on the board and this machine runs a read-only scratch turn that proposes how the selected cards should be split across agents; accepting the proposal is what cuts worktrees and starts work. From **0.79.0** that planning turn is relayed the same way a session turn is — the reads, greps and thoughts the daemon was already printing behind `[plan]` now reach the press itself, along with the two facts only this side can see: the CLI actually starting, and the press waiting for the checkout while a ship or another turn holds it. A planning CLI that wedges is stopped after fifteen minutes and the press is reported failed in the machine's own words, rather than sitting silent until the server expires it half an hour later.
 
 ## Sharing a preview
 

package/bin/lib/authproxy.mjs

@@ -92,12 +92,28 @@ import { createServer, request } from 'node:http';
 import { randomBytes, createHash, timingSafeEqual } from 'node:crypto';
 import { GRANT_COOKIE, cookieValues, safePathname, safeRelative, stripCookie, verifyGrant } from './grant.mjs';
 
-/** Failed attempts before the proxy stops answering at all. A quick tunnel's
- *  hostname is unguessable, so this is not the primary control — it is what
- *  turns a discovered URL from an offline guessing target into a visible,
- *  self-closing incident. */
+/** Wrong-password attempts from ONE source before that source's Basic
+ *  attempts are refused outright. A quick tunnel's hostname is unguessable,
+ *  so this is not the primary control — but it is KNOWN to every past
+ *  member, tester and password recipient, whose access cannot be recalled.
+ *  The threshold is per source because one global counter made 25 wrong
+ *  guesses from any URL holder a kill switch on everyone else's share. */
 const MAX_FAILED = 25;
 
+/** Counted failures across ALL sources before the whole share tears down.
+ *  The per-source block above answers a single abuser; this answers a
+ *  DISTRIBUTED guessing run (addresses rotating to stay under MAX_FAILED
+ *  each) — the original self-closing-incident property, kept at a threshold
+ *  ordinary use cannot reach: a blocked source stops counting, so getting
+ *  here takes eight independent sources each burning their full allowance. */
+const MAX_FAILED_TOTAL = 200;
+
+/** Bound on the per-source map — a rotating attacker must not grow daemon
+ *  memory without limit. Eviction is oldest-first and CAN un-block an evicted
+ *  source, but cycling 500 fresh sources costs at least 500 counted failures,
+ *  and the global backstop closes the share long before that. */
+const MAX_SOURCES = 500;
+
 const digest = (s) => createHash('sha256').update(String(s)).digest();
 
 /** Constant-time over sha256 digests, so length never leaks and a missing
@@ -116,8 +132,10 @@ function sameSecret(a, b) {
  * hard failure. Binds loopback only; cloudflared connects locally, and the
  * password is what gates the public hostname.
  *
- * `onAbuse` fires once, after MAX_FAILED rejected attempts, so the caller can
- * tear the whole share down rather than leaving a URL under attack.
+ * `onAbuse` fires once, after MAX_FAILED_TOTAL rejected attempts across all
+ * sources, so the caller can tear the whole share down rather than leaving a
+ * URL under attack. A single source is blocked on its own, at MAX_FAILED,
+ * without ending anybody else's share.
  */
 export function startAuthProxy({ targetPort, log, onAbuse, grantSecret, shareId, authorizeUrl }) {
   // ALL THREE OR NONE. Two of the three is a gate that cannot bounce anybody:
@@ -134,44 +152,82 @@ export function startAuthProxy({ targetPort, log, onAbuse, grantSecret, shareId,
   const password = randomBytes(24).toString('base64url');
   const expected = 'Basic ' + Buffer.from(`${user}:${password}`).toString('base64');
 
-  let failed = 0;
+  let failedTotal = 0;
   let abused = false;
+  /** source → wrong-password count, insertion-ordered so eviction below is
+   *  oldest-first. A source at MAX_FAILED is BLOCKED: its Basic attempts are
+   *  refused BEFORE the comparison and stop counting toward the total. */
+  const failedBySource = new Map();
   /** The payload of the last validly-signed but EXPIRED grant seen, so a
    *  tester can be re-bounced with the token inside it. */
   let lastExpired = null;
 
+  /** cloudflared forwards the real client address in Cf-Connecting-Ip; a
+   *  direct local connection (the machine's own curl, the tests) has only the
+   *  socket. The header is attacker-writable in principle, but lying in it
+   *  only SPREADS one attacker across per-source counters — which is exactly
+   *  the shape MAX_FAILED_TOTAL exists to answer. */
+  const sourceOf = (req) =>
+    String(req.headers['cf-connecting-ip'] || req.socket?.remoteAddress || 'unknown');
+
+  const sourceBlocked = (req) => (failedBySource.get(sourceOf(req)) ?? 0) >= MAX_FAILED;
+
+  const noteFailure = (req) => {
+    const src = sourceOf(req);
+    const count = (failedBySource.get(src) ?? 0) + 1;
+    // Delete-then-set so Map insertion order tracks recency, making the
+    // eviction below an LRU rather than "whoever failed first".
+    failedBySource.delete(src);
+    failedBySource.set(src, count);
+    if (failedBySource.size > MAX_SOURCES) {
+      failedBySource.delete(failedBySource.keys().next().value);
+    }
+    if (count === MAX_FAILED) {
+      log?.(`preview gate: ${count} failed attempts from ${src} — refusing that source.`);
+    }
+    // MONOTONE, never reset by a success: a distributed run has no successes
+    // to hide behind, and a legitimate share cannot reach the backstop —
+    // every source stops counting at MAX_FAILED, so 200 needs eight distinct
+    // sources each exhausting their own allowance.
+    failedTotal += 1;
+    if (failedTotal >= MAX_FAILED_TOTAL && !abused) {
+      abused = true;
+      log?.(`preview gate: ${failedTotal} failed attempts across sources — closing the share.`);
+      try {
+        onAbuse?.();
+      } catch {
+        /* the caller's teardown is best-effort */
+      }
+    }
+  };
+
   /**
    * A PURE CREDENTIAL PREDICATE — no method, no Accept, no path. That is what
    * lets the websocket upgrade handler reuse it verbatim, and it is why routing
    * decisions live in the request handler instead.
    *
-   * Tristate-plus: 'ok' | 'none' | 'expired' | 'forged' | 'badpass'.
+   * Tristate-plus: 'ok' | 'none' | 'expired' | 'forged' | 'badpass' | 'blocked'.
    */
   const credential = (req) => {
     if (abused) return 'badpass';
-    if (sameSecret(req.headers['authorization'], expected)) {
-      failed = 0;
-      return 'ok';
-    }
     // ONLY A WRONG PASSWORD COUNTS AS AN ATTEMPT, and this is a reason rather
     // than a preference. A forged HMAC is not brute-forceable, so counting it
     // buys nothing — while counting it would hand any stranger who finds the
-    // hostname a 25-request KILL SWITCH on the owner's share, because onAbuse
-    // tears the whole thing down. An expired-but-validly-signed grant must
-    // never count either, or a viewer who left a tab open overnight closes the
-    // share on their own reload. MAX_FAILED keeps its exact meaning, which is
-    // also why the 'abuse' ended-reason sentence stays true.
+    // hostname a kill switch on the owner's share, because onAbuse tears the
+    // whole thing down. An expired-but-validly-signed grant must never count
+    // either, or a viewer who left a tab open overnight closes the share on
+    // their own reload.
     if (req.headers['authorization']) {
-      failed += 1;
-      if (failed >= MAX_FAILED && !abused) {
-        abused = true;
-        log?.(`preview gate: ${failed} failed attempts — closing the share.`);
-        try {
-          onAbuse?.();
-        } catch {
-          /* the caller's teardown is best-effort */
-        }
+      // A blocked source is refused BEFORE the comparison — a block that
+      // still grades guesses would let the brute force run to a correct hit.
+      if (sourceBlocked(req)) return 'blocked';
+      if (sameSecret(req.headers['authorization'], expected)) {
+        // Per-source only: a shared NAT recovers when one person behind it
+        // gets the password right; failedTotal stays monotone (see above).
+        failedBySource.delete(sourceOf(req));
+        return 'ok';
       }
+      noteFailure(req);
       return 'badpass';
     }
 
@@ -188,8 +244,6 @@ export function startAuthProxy({ targetPort, log, onAbuse, grantSecret, shareId,
     return String(req.headers.cookie ?? '').includes(GRANT_COOKIE) ? 'forged' : 'none';
   };
 
-  const authed = (req) => credential(req) === 'ok';
-
   /**
    * The CSRF backstop for the partitioned cookie (header rule 4a): a browser
    * old enough to ignore `Partitioned` while honouring `SameSite=None` will
@@ -388,6 +442,14 @@ export function startAuthProxy({ targetPort, log, onAbuse, grantSecret, shareId,
     }
     // 3. One predicate.
     const verdict = credential(req);
+    // A blocked source gets 429, not the challenge — a WWW-Authenticate here
+    // would invite the retry the block exists to end. Only that source's
+    // Basic attempts are refused; every other viewer's share is untouched.
+    if (verdict === 'blocked') {
+      res.writeHead(429, { 'Content-Type': 'text/plain', ...noStore });
+      res.end('too many failed attempts from this address');
+      return;
+    }
     if (verdict !== 'ok') {
       if (grants && verdict !== 'badpass' && isBrowserNav(req)) return bounce(req, res, verdict);
       return challenge(res);
@@ -435,10 +497,17 @@ export function startAuthProxy({ targetPort, log, onAbuse, grantSecret, shareId,
     }
     // NEVER 302 HERE — browsers fail an upgrade rather than following a 3xx, so
     // a bounce would read as a dead dev server. The cookie IS sent on a
-    // same-origin handshake, so `authed` works unchanged; a cookie-less upgrade
-    // stays a 401 and the page's HMR client reconnects once the human has
-    // re-authenticated in the main document.
-    if (!authed(req)) {
+    // same-origin handshake, so the predicate works unchanged; a cookie-less
+    // upgrade stays a 401 and the page's HMR client reconnects once the human
+    // has re-authenticated in the main document. A blocked source's Basic
+    // handshake gets the same 429 the request path sends, and no challenge.
+    const upgradeVerdict = credential(req);
+    if (upgradeVerdict === 'blocked') {
+      socket.write('HTTP/1.1 429 Too Many Requests\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+    if (upgradeVerdict !== 'ok') {
       socket.write('HTTP/1.1 401 Unauthorized\r\nWWW-Authenticate: Basic realm="Flowviant preview"\r\n\r\n');
       socket.destroy();
       return;

package/bin/lib/claude.mjs

@@ -12,10 +12,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { SAFE, MODEL } from './config.mjs';
+import { SAFE } from './config.mjs';
 import { runtimeById, humanizeClaudeTool } from './runtimes.mjs';
 
 // Every prompt/kickoff constant lives in prompts.mjs and is re-exported here:
@@ -141,20 +138,6 @@ export const blockedId = (out) => {
   return m ? m[1] : null;
 };
 
-export function mcpConfigFor(token, mcpUrl) {
-  const dir = mkdtempSync(join(tmpdir(), 'flowviant-'));
-  const p = join(dir, 'mcp.json');
-  writeFileSync(
-    p,
-    JSON.stringify({
-      mcpServers: {
-        flowviant: { type: 'http', url: mcpUrl, headers: { Authorization: `Bearer ${token}` } },
-      },
-    })
-  );
-  return { dir, path: p };
-}
-
 /**
  * Hand a runtime the flowviant MCP server, however that runtime wants it.
  *

package/bin/lib/deploy.mjs

@@ -257,7 +257,13 @@ export function processDeployJobs(jobs, ctx) {
          */
         let missed = 0;
         beat = setInterval(() => {
-          void post('deploy-heartbeat', { jobId: job.id, pubkey: ctx.myPubB64() })
+          void post('deploy-heartbeat', {
+            jobId: job.id,
+            pubkey: ctx.myPubB64(),
+            // Instance rides the heartbeat too, or a same-box sibling's beat
+            // could keep a dead claimer's job "running" past the stale sweep.
+            instance: DAEMON_INSTANCE,
+          })
             .then(() => {
               missed = 0;
             })
@@ -385,6 +391,12 @@ async function report(job, ctx, outcome, stillBeating = () => true) {
   const body = {
     jobId: job.id,
     pubkey: ctx.myPubB64(),
+    // The same term the claim carries, for the same reason: the pubkey is one
+    // keypair per home directory, so two daemons on one box share it, and a
+    // stale holder's late report would otherwise settle the RECLAIMER's
+    // running job. The server matches it when present; an older server
+    // ignores the extra key.
+    instance: DAEMON_INSTANCE,
     ok: !!outcome.ok,
     deploymentId: outcome.deploymentId ?? null,
     healthOk: outcome.healthOk ?? null,

package/bin/lib/env.mjs

@@ -249,7 +249,9 @@ export async function loadCachedEnv(projectId) {
   if (!cached) return false;
   values = cached.values ?? [];
   bundleVersion = cached.bundleVersion ?? -1;
-  knownTargetFiles = new Set(cached.knownFiles ?? values.map((v) => v.targetFile));
+  // Filtered even though we wrote the cache: this set feeds removeStaleEnvFile,
+  // and a cache file predates whatever rules the running daemon enforces.
+  knownTargetFiles = new Set((cached.knownFiles ?? values.map((v) => v.targetFile)).filter(isSafeTarget));
   cachedProjectId = projectId;
   return values.length > 0;
 }
@@ -264,8 +266,8 @@ export async function loadCachedEnv(projectId) {
  * only and never touches the user's repo". Git does not read that file: it
  * resolves `info/exclude` against $GIT_COMMON_DIR — the main `.git` — so in
  * every linked worktree the daemon creates, the exclusion did nothing at all.
- * The plaintext secret files stayed visible to `git add -A`, which is what
- * `checkpointWip` runs before force-pushing a WIP commit to the remote.
+ * The plaintext secret files stayed visible to `git add -A` — the first thing
+ * an agent runs before committing and pushing the branch it is working on.
  *
  * `--git-common-dir` is asked of git rather than derived, because that is the
  * one answer that cannot drift from what git itself will consult. The file is
@@ -307,13 +309,25 @@ export function excludeInWorktree(wt, relPaths) {
   }
 }
 
+/** MUST match the server's isSafeEnvTargetFile (env.schema.ts) — the server
+ *  validates at intake, but this file also refills paths from the on-disk
+ *  cache and hands them to rmSync, so the daemon holds its own line rather
+ *  than trusting either source. `.git` is refused at ANY depth and
+ *  case-insensitively (git treats `.GIT` the same on case-insensitive
+ *  filesystems): a target of `.git/hooks/pre-commit` would turn a
+ *  materialized value into code git runs on the operator's next commit —
+ *  check-ignore alone must not be the only thing standing there. The control
+ *  range subsumes the old bare `\0` check and keeps a newline out of a PATH,
+ *  where nothing downstream expects one. */
 const isSafeTarget = (p) =>
-  p &&
+  typeof p === 'string' &&
+  p.length > 0 &&
   p.length <= 200 &&
   !p.includes('\\') &&
-  !p.includes('\0') &&
+  // eslint-disable-next-line no-control-regex
+  !/[\x00-\x1f\x7f]/.test(p) &&
   !p.startsWith('/') &&
-  p.split('/').every((s) => s.length > 0 && s !== '.' && s !== '..');
+  p.split('/').every((s) => s.length > 0 && s !== '.' && s !== '..' && s.toLowerCase() !== '.git');
 
 /** Is this path TRACKED in the repo? info/exclude only hides UNTRACKED files —
  *  materializing secrets into a tracked file would make them stageable and
@@ -406,8 +420,16 @@ function renderEnvFile(list) {
 }
 
 /** Delete a materialized file from a worktree, but ONLY if it's ours (carries
- *  our header) and not git-tracked — never touch a file we didn't write. */
+ *  our header) and not git-tracked — never touch a file we didn't write.
+ *
+ *  `rel` gets the SAME gate the write path has: it arrives via
+ *  knownTargetFiles, which is refilled from the server bundle and from the
+ *  on-disk cache, and this function joins it to a worktree and calls rmSync.
+ *  The isTrackedInGit check cannot stand in for validation — `ls-files` on a
+ *  path outside the worktree THROWS, the catch reads as "not tracked", and
+ *  the deletion proceeds. A delete primitive validates its own input. */
 function removeStaleEnvFile(wt, rel) {
+  if (!isSafeTarget(rel)) return;
   if (isTrackedInGit(wt, rel)) return;
   const abs = join(wt, rel);
   try {
@@ -460,8 +482,8 @@ export function materializeInto(wt) {
 
   // Exclude BEFORE writing, not after. The old order wrote plaintext first and
   // tried to hide it afterwards, so every failure mode — and the exclude file
-  // being the wrong one, which it was — left a readable secret in a tree that
-  // `checkpointWip` force-pushes.
+  // being the wrong one, which it was — left a readable secret sitting where
+  // the next `git add -A` in that tree would stage it for a push.
   excludeInWorktree(wt, [...byFile.keys()]);
 
   const written = [];
@@ -477,9 +499,9 @@ export function materializeInto(wt) {
       anyProblem = true;
       continue;
     }
-    // The load-bearing check. A materialized secret sits in a worktree whose
-    // whole tree gets `git add -A`'d and force-pushed by the WIP checkpoint, so
-    // "git cannot see this file" is a precondition for writing it, not a nicety.
+    // The load-bearing check. A materialized secret sits in a worktree where an
+    // agent runs `git add -A` and pushes as a matter of course, so "git cannot
+    // see this file" is a precondition for writing it, not a nicety.
     if (!isIgnoredInGit(wt, file)) {
       warn(`env: "${file}" is not gitignored — refusing to write secrets there. Add it to .gitignore. Its keys are NOT materialized.`);
       refusedForGit.push(file);
@@ -557,17 +579,6 @@ export function materializeInto(wt) {
   everMaterialized = true;
 }
 
-/**
- * The secret files this daemon has materialized into `wt`.
- *
- * Exists so anything that stages the whole tree can subtract them by pathspec.
- * Belt to the check-ignore braces: `git add -A` obeys .gitignore, so a properly
- * ignored file is already safe — but "already safe" was the assumption that put
- * plaintext on a remote branch, and a second, independent mechanism is cheap.
- */
-export function materializedFiles(wt) {
-  return [...(lastFilesByWorktree.get(wt) ?? [])];
-}
 
 // ── Uplink scrubbing ───────────────────────────────────────────────────────
 
@@ -704,7 +715,9 @@ export async function handleRosterEnv(env, { projectId } = {}) {
       bundleVersion = bundle.bundleVersion;
       // Fold the current target files into the persisted known set so stale
       // cleanup survives a restart (a key deleted while down still gets swept).
-      for (const v of values) knownTargetFiles.add(v.targetFile);
+      // Filtered at the fill, not just at the delete: this set is persisted,
+      // so an unsafe path admitted here would outlive the bundle that sent it.
+      for (const v of values) if (isSafeTarget(v.targetFile)) knownTargetFiles.add(v.targetFile);
       if (cachedProjectId) writeCache(cachedProjectId, { values, bundleVersion, knownFiles: [...knownTargetFiles] });
       ok(`${c.cyan('env')} ${c.dim(`— synced ${values.length} secret${values.length === 1 ? '' : 's'} (env v${bundleVersion})`)}`);
       return { changed: true };

package/bin/lib/fleet.mjs

@@ -38,7 +38,6 @@ import { handleVersionSignal } from './update.mjs';
 import {
   git,
   resetWorktree,
-  ensureWorktree,
   repoRootOrDie,
   detectBaseRef,
   originSlug,
@@ -46,7 +45,6 @@ import {
   isValidPrUrl,
   isValidBranch,
   isSafePathSegment,
-  worktreeDiffstat,
 } from './git.mjs';
 import { c, info, note, ok, warn, fail } from './ui.mjs';
 import { revertPatch, withPatchLock } from './patch.mjs';
@@ -321,7 +319,13 @@ async function maybeReportRepoState({ repoRoot, baseRef }) {
   repoStateScanAt = Date.now();
   let payload;
   try {
-    const state = repoState(repoRoot, getBaseRef());
+    // The PARAM, and nothing else: this function sits at MODULE scope, where
+    // runFleetDaemon's `getBaseRef` closure does not exist. An earlier version
+    // reached for it anyway, the ReferenceError landed in the catch below —
+    // written for an unreadable repo, silent by design — and this endpoint was
+    // never once posted to. The caller reads the loop's live `baseRef` at call
+    // time, so the value here is always current.
+    const state = repoState(repoRoot, baseRef);
     if (!state) return; // not readable — say nothing rather than say "none"
     payload = JSON.stringify(state);
   } catch {
@@ -773,33 +777,6 @@ export async function runFleetDaemon() {
     return run;
   };
 
-  /** A clean detached checkout at base — what "the real code" has to mean for a
-   *  question about the repo, rather than whatever half-finished state an agent
-   *  worktree happens to be in. Shared by the plan check and consults. */
-  const ensureWikiWorktree = () => {
-    if (!existsSync(wikiWt)) {
-      try {
-        git(['worktree', 'add', '--detach', wikiWt, baseRef], repoRoot);
-      } catch {
-        git(['worktree', 'prune'], repoRoot);
-        git(['worktree', 'add', '--detach', wikiWt, baseRef], repoRoot);
-      }
-      return;
-    }
-    // It already exists — which means it is pinned to whatever base pointed at
-    // when it was FIRST created, possibly weeks ago. "Reads the real code" has
-    // to mean the current base, so re-point it. Best-effort: a stale answer
-    // beats no answer, and the next turn tries again.
-    try {
-      git(['fetch', 'origin', '--quiet'], repoRoot);
-      git(['checkout', '--detach', baseRef], wikiWt);
-      git(['reset', '--hard', baseRef], wikiWt);
-      git(['clean', '-fd'], wikiWt);
-    } catch {
-      /* offline, or a turn left it dirty — read what we have */
-    }
-  };
-
   // Machine telemetry — what the box is doing with itself, for the admin view.
   const MACHINE_URL = FLEET_URL.replace(/\/agents\/?$/, '/machine');
 
@@ -1146,7 +1123,24 @@ export async function runFleetDaemon() {
       // the turn still reads the real changed files; this catches pages whose
       // frontmatter file list has drifted, or that document a concept rather
       // than a directory.
-      dirtiesPages: Array.isArray(dirtiesPages) ? dirtiesPages : [],
+      //
+      // SANITIZED AT THE INTAKE, because every entry is server-supplied text
+      // that ends up interpolated into a prompt and printed by the drain's
+      // narration: a control byte can repaint the console it lands on, a
+      // newline can break out of the prompt's own list framing, and an
+      // unbounded array of unbounded strings is an unbounded prompt. This is
+      // the belt at the intake; the prompt keeps its own fence at the
+      // interpolation.
+      dirtiesPages: (Array.isArray(dirtiesPages) ? dirtiesPages : [])
+        .filter((p) => typeof p === 'string')
+        .slice(0, 40)
+        .map((p) =>
+          p
+            .replace(/[\u0000-\u001f\u007f]/g, ' ')
+            .trim()
+            .slice(0, 300)
+        )
+        .filter(Boolean),
       // THE COMMITS THAT SHIPPED — what changedFilesForShas resolves against.
       // Dropping this here was the whole 0.54.0/0.54.1 defect: the server sent
       // shas on every reground job, this function never stored them, and the
@@ -1686,12 +1680,7 @@ export async function runFleetDaemon() {
     // tab. Without this the daemon that lost the lease removes the worktree the
     // winner is working in — absence would mean "somebody else won" instead of
     // "the tab closed".
-    retireWorkSessions(
-      Array.isArray(roster.activeWorkSessions)
-        ? roster.activeWorkSessions
-        : roster.activeWorkSessions,
-      roster.sessionsHeldElsewhere
-    );
+    retireWorkSessions(roster.activeWorkSessions, roster.sessionsHeldElsewhere);
     // Diffs somebody has open and is waiting on. Project-scoped rather than
     // per-session: `git show` runs from the repo ROOT, which can see a closed
     // tab's branch and a shipped commit on main alike.