@north-light/crouter 0.3.302 → 0.3.304

package/dist/core/runtime/broker/fault-retry.js

@@ -22,6 +22,11 @@ export class FaultRetry {
     notFoundModels = new Set();
     providerFallbackInFlight = null;
     notFoundFallbackInFlight = null;
+    // A fallback can learn its target cannot hold this session before the
+    // current turn settles. Keep that outcome here rather than on the engine's
+    // agent_end staging field: message_end precedes agent_end, which resets that
+    // field for the ordinary provider result.
+    stagedCapacityFailure = null;
     constructor(deps) {
         this.deps = deps;
     }
@@ -35,6 +40,7 @@ export class FaultRetry {
         this.clearTimer();
         this.providerFallbackInFlight = null;
         this.notFoundFallbackInFlight = null;
+        this.stagedCapacityFailure = null;
     }
     onEvent(event) {
         this.maybeSwitchProviderForRetry(event);
@@ -54,6 +60,8 @@ export class FaultRetry {
         const watchdogAbort = generation.stagedWatchdogAbort;
         const refreshAbort = generation.stagedRefreshAbort;
         const overflowFailure = generation.stagedOverflowFailure;
+        const capacityFailure = this.stagedCapacityFailure?.generation === generation ? this.stagedCapacityFailure : null;
+        this.stagedCapacityFailure = null;
         generation.stagedProviderAgentEnd = null;
         generation.stagedWatchdogAbort = false;
         generation.stagedRefreshAbort = false;
@@ -63,6 +71,14 @@ export class FaultRetry {
         // admitted retry therefore carries from its durable episode, while an
         // initial provider failure still reads from the ordinary marker.
         const prior = readFault(this.deps.nodeId);
+        // A persona gate runs before Pi contacts a provider. It records a typed
+        // local API transport failure, then Pi represents that thrown error as a
+        // generic provider-looking agent_end. Keep its actual boundary instead of
+        // turning it into a fatal pi→provider `other` fault.
+        if (prior?.link === 'broker↔crtrd' && prior.kind === 'connection') {
+            clearProviderRetryEpisode(this.deps.nodeId);
+            return;
+        }
         const durableEpisode = readProviderRetryEpisode(this.deps.nodeId);
         const episodeFault = this.isActiveAutoFault(prior) && prior.link === 'pi→provider'
             ? prior
@@ -76,12 +92,12 @@ export class FaultRetry {
             : { since: episodeFault.since, anchorEntryId: episodeFault.anchorEntryId, attempt: episodeFault.retry.attempt };
         const messages = Array.isArray(agentEnd?.messages) ? agentEnd.messages : [];
         const last = [...messages].reverse().find((message) => typeof message === 'object' && message !== null && message.role === 'assistant');
-        if (overflowFailure !== null) {
+        if (capacityFailure !== null || overflowFailure !== null) {
             clearFault(this.deps.nodeId, { link: 'pi→provider' });
             clearProviderRetryEpisode(this.deps.nodeId);
             recordFault(this.deps.nodeId, {
                 link: 'pi→provider', op: 'context overflow recovery', kind: 'context-overflow', retry: { disposition: 'fatal' },
-                message: overflowFailure.errorMessage, anchorEntryId: settledSession.sessionManager.getLeafId?.() ?? undefined,
+                message: capacityFailure?.errorMessage ?? overflowFailure.errorMessage, anchorEntryId: settledSession.sessionManager.getLeafId?.() ?? undefined,
             });
             return;
         }
@@ -250,9 +266,23 @@ export class FaultRetry {
         const routes = expandModelCandidates(routeRequest, envNodeCwd() ?? this.deps.cfg.cwd, envProfileId());
         const current = parseModelSpec(currentSpec);
         const liveRank = routes.find((candidate) => `${candidate.providerId}/${candidate.modelId}` === current.modelSpec && candidate.thinkingLevel === current.thinkingLevel)?.rank;
-        const nextRoute = liveRank === undefined ? undefined : routes.slice(liveRank + 1).find((candidate) => !this.failedRetryRoutes.has(candidate.routeId) && resolveProviderCandidates([{ ...candidate, ...probeRouteAvailability(candidate, this.deps.registryOf(candidateServices)), automaticFallback: true }]).candidates.length > 0);
-        if (nextRoute === undefined)
+        const fallback = liveRank === undefined
+            ? { route: undefined, capacityExhausted: false }
+            : this.nextEligibleFallbackRoute(routes.slice(liveRank + 1), this.deps.registryOf(candidateServices), candidateSession.getContextUsage()?.tokens, (candidate) => !this.failedRetryRoutes.has(candidate.routeId));
+        if (fallback.route === undefined) {
+            if (fallback.capacityExhausted) {
+                this.stageCapacityFailure(generation, candidateSession);
+                // Pi creates its retry AbortController immediately after it emits this
+                // event. Defer the abort so it cancels that controller, then lets the
+                // normal agent_settled path publish the staged fatal outcome.
+                queueMicrotask(() => {
+                    if (this.deps.installedGeneration() === generation && this.deps.currentSession() === candidateSession)
+                        candidateSession.abortRetry();
+                });
+            }
             return;
+        }
+        const nextRoute = fallback.route;
         const fallbackPromise = (async () => {
             const target = this.deps.registryOf(candidateServices).find(nextRoute.providerId, nextRoute.modelId);
             if (!target)
@@ -290,9 +320,15 @@ export class FaultRetry {
         const routeRequest = modelRequestFromConfig(this.deps.cfg.model, envModelIntent(), false);
         const routes = routeRequest ? expandModelCandidates(routeRequest, envNodeCwd() ?? this.deps.cfg.cwd, envProfileId()) : [];
         const liveRank = routes.find((candidate) => `${candidate.providerId}/${candidate.modelId}` === current.modelSpec && candidate.thinkingLevel === current.thinkingLevel)?.rank;
-        const nextRoute = liveRank === undefined ? undefined : routes.slice(liveRank + 1).find((candidate) => !this.notFoundModels.has(`${candidate.providerId}/${candidate.modelId}`) && resolveProviderCandidates([{ ...candidate, ...probeRouteAvailability(candidate, this.deps.registryOf(candidateServices)), automaticFallback: true }]).candidates.length > 0);
-        if (!nextRoute)
+        const fallback = liveRank === undefined
+            ? { route: undefined, capacityExhausted: false }
+            : this.nextEligibleFallbackRoute(routes.slice(liveRank + 1), this.deps.registryOf(candidateServices), candidateSession.getContextUsage()?.tokens, (candidate) => !this.notFoundModels.has(`${candidate.providerId}/${candidate.modelId}`));
+        if (fallback.route === undefined) {
+            if (fallback.capacityExhausted)
+                this.stageCapacityFailure(generation, candidateSession);
             return;
+        }
+        const nextRoute = fallback.route;
         const target = `${nextRoute.providerId}/${nextRoute.modelId}${nextRoute.thinkingLevel ? `:${nextRoute.thinkingLevel}` : ''}`;
         const fallbackPromise = (async () => {
             const model = this.deps.registryOf(candidateServices).find(nextRoute.providerId, nextRoute.modelId);
@@ -323,6 +359,38 @@ export class FaultRetry {
         });
         this.notFoundFallbackInFlight = fallbackPromise;
     }
+    nextEligibleFallbackRoute(routes, registry, contextTokens, include) {
+        let available = 0;
+        let tooSmall = 0;
+        for (const candidate of routes) {
+            if (!include(candidate))
+                continue;
+            if (resolveProviderCandidates([{ ...candidate, ...probeRouteAvailability(candidate, registry), automaticFallback: true }]).candidates.length === 0)
+                continue;
+            const target = registry.find(candidate.providerId, candidate.modelId);
+            if (target === undefined)
+                continue;
+            available++;
+            if (this.targetCannotFitContext(target.contextWindow, contextTokens)) {
+                tooSmall++;
+                continue;
+            }
+            return { route: candidate, capacityExhausted: false };
+        }
+        return { route: undefined, capacityExhausted: available > 0 && available === tooSmall };
+    }
+    targetCannotFitContext(contextWindow, contextTokens) {
+        return Number.isFinite(contextWindow) && Number.isFinite(contextTokens) && contextWindow < contextTokens;
+    }
+    stageCapacityFailure(generation, session) {
+        const tokens = session.getContextUsage()?.tokens;
+        this.stagedCapacityFailure = {
+            generation,
+            errorMessage: Number.isFinite(tokens)
+                ? `All available fallback models have context windows smaller than the current conversation (${tokens} tokens).`
+                : 'All available fallback models have context windows smaller than the current conversation.',
+        };
+    }
     recordPendingProviderFault(session, input) {
         const sessionFile = this.sessionFile(session);
         // A pathless session cannot be crash-recovered, but its live broker still

package/dist/core/runtime/broker-persona-guidance.js

@@ -1,5 +1,7 @@
 import { contextDir } from '../canvas/paths.js';
+import { isDaemonTransportApiError } from '../../api/errors.js';
 import { emitEvent } from '../events/emit.js';
+import { clearFault, recordFault } from './fault.js';
 import { brokerExtensionState, commitBrokerPersonaAck } from './broker/daemon-ops.js';
 import { readRoadmap, roadmapPath } from './roadmap.js';
 import { buildSubPersonaMenu, renderConfigChangeDelta } from '../substrate/render.js';
@@ -137,9 +139,19 @@ export function installPersonaTransitionGate(nodeId, session) {
                 for (const context of new Set([active, messages, transformed]))
                     context.push(message);
             });
+            clearFault(nodeId, { link: 'broker↔crtrd' });
             return transformed;
         }
         catch (error) {
+            if (isDaemonTransportApiError(error)) {
+                recordFault(nodeId, {
+                    link: 'broker↔crtrd',
+                    op: 'persona transition',
+                    kind: 'connection',
+                    retry: { disposition: 'manual' },
+                    message: error.message,
+                });
+            }
             emitEvent({
                 event: 'broker.daemon.operation.failed',
                 level: 'error',

package/dist/core/runtime/broker.js

@@ -375,11 +375,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
         notifyTurnAccepted: () => notifyTurnAccepted(),
         emitStartupMilestone,
         formatModelSpec,
-        refreshIntent: async () => (await brokerExtensionState(nodeId)).node.intent === 'refresh',
-        onRefreshIntentError: (error) => {
-            emitEvent({ level: 'error', event: 'broker.daemon_state.read_failed', error });
-            disposeAndExit('daemon-state-read-failed', 1);
-        },
     });
     const buildSnapshot = (client) => {
         const liveSession = rebind.session();

package/dist/core/runtime/fault.js

@@ -31,7 +31,7 @@ function faultPriority(fault) {
         return 2;
     return 1;
 }
-const faultLinks = ['pi→provider', 'viewer↔broker', 'relay↔broker', 'viewer↔crtrd', 'daemon→node', 'crtr→pi'];
+const faultLinks = ['pi→provider', 'viewer↔broker', 'relay↔broker', 'viewer↔crtrd', 'broker↔crtrd', 'daemon→node', 'crtr→pi'];
 const faultKinds = ['rate-limit', 'overloaded', 'connection', 'auth', 'protocol', 'context-overflow', 'other', 'wedged', 'model-not-found'];
 function parseFault(raw) {
     try {

package/dist/core/runtime/host.js

@@ -319,7 +319,16 @@ export const headlessBrokerHost = {
                     });
                     finish({ code, signal });
                 });
-                spawned.once('error', () => finish({ code: null, signal: null }));
+                spawned.once('error', (error) => {
+                    emitEvent({
+                        level: 'error',
+                        event: 'broker.launch.failed',
+                        node_id: nodeId,
+                        error,
+                        fields: { uptime_ms: Date.now() - launchedAt },
+                    });
+                    finish({ code: null, signal: null });
+                });
             });
             spawned.unref();
             const handle = { pid: spawned.pid ?? null, exited };

package/dist/core/runtime/spawn.js

@@ -15,7 +15,7 @@ import { spawnNode, currentNodeContext, rootOfSpine, newNodeId, preflightNodeId
 import { resolveProfileOperand } from '../profiles/manifest.js';
 import { selectProfileForCwd, selectProfileForCwdReadOnly } from '../profiles/select.js';
 import { buildLaunchSpecAsync, buildPiArgv } from './launch.js';
-import { createManagedWorktree, rollbackManagedWorktree } from '../worktree.js';
+import { createManagedWorktreeAsync, rollbackManagedWorktreeAsync } from '../worktree-mutation-async.js';
 import { usage, brokerLaunchFailed } from '../errors.js';
 import { writeGoal } from './kickoff.js';
 import { appendSituationalContext, formatSituationalProse } from './situational-context.js';
@@ -25,7 +25,6 @@ import { encodeKickoffOrigin, KICKOFF_ORIGIN_ENV } from './stamp/protocol.js';
 import { canonicalSessionFile, contextDir, findNodeBySessionFile, getNode, fullName, recordPid, setFrozen } from '../canvas/index.js';
 import { boundFleet, brokerThresholdsForDaemon } from './fleet.js';
 import { emitEvent } from '../events/emit.js';
-import { jobDir } from '../canvas/paths.js';
 import { openViewerWindow, focusOf, windowOfPane, } from './placement.js';
 import { waitForBrokerViewSocket } from './placement-tmux.js';
 import { transition } from './lifecycle.js';
@@ -259,7 +258,7 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
     let spawnCwd = opts.cwd;
     try {
         if (wantsWorktree) {
-            managedWorktree = createManagedWorktree(opts.worktreeCwd ?? opts.cwd, nodeId, opts.worktreeBase);
+            managedWorktree = await createManagedWorktreeAsync(opts.worktreeCwd ?? opts.cwd, nodeId, opts.worktreeBase);
             spawnCwd = managedWorktree.path;
         }
         // Spine: a managed child reports up to its spawner (has a manager); an
@@ -409,7 +408,7 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
         if (placed.pid === null) {
             const error = new Error(`broker host returned no pid for ${meta.node_id}`);
             transition(meta.node_id, 'crash', { reason: 'launch_failed', outcome: launchFailureOutcome(error) });
-            throw brokerLaunchFailed(`failed to launch the broker engine for ${meta.node_id} (${meta.name}) — the node was not started.`, `Inspect the broker log for the underlying cause (${jobDir(meta.node_id)}/broker.log) and verify the pi engine can start in this environment.`);
+            throw brokerLaunchFailed(`failed to launch the broker engine for ${meta.node_id} (${meta.name}) — the node was not started.`, `Inspect canonical event diagnostics with \`crtr sys logs --node ${meta.node_id}\`, then verify the pi engine can start in this environment.`);
         }
         recordPid(meta.node_id, placed.pid);
         // A root created through `node new --root` must accept viewers before the
@@ -425,7 +424,7 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
                 ? `the root broker ${meta.node_id} could not start — ${why}`
                 : `the root broker ${meta.node_id} never bound its view socket — it was not started.`, why !== null
                 ? 'Resolve the cause named above, then retry.'
-                : `The broker engine exited before binding its view socket. Inspect ${jobDir(meta.node_id)}/broker.log for the underlying cause (a missing dependency, model auth, or a crash), then retry.`);
+                : `The broker engine exited before binding its view socket. Inspect canonical event diagnostics with \`crtr sys logs --node ${meta.node_id}\`, then retry.`);
         }
         // A --root opens NO viewer from here. spawnChild runs daemon-side only, and
         // the daemon is paneless by construction (manage.ts strips TMUX/TMUX_PANE
@@ -484,7 +483,7 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
         // worktree — the node stays alive (crashed, if the launch itself failed)
         // with its worktree intact rather than pinned to a deleted path.
         if (managedWorktree !== undefined && nodeId !== undefined && getNode(nodeId) === null) {
-            rollbackManagedWorktree(managedWorktree);
+            await rollbackManagedWorktreeAsync(managedWorktree);
         }
         throw err;
     }

package/dist/core/shell-segments.d.ts

@@ -0,0 +1,42 @@
+/** One shell word. `opaque` marks a token whose text came from inside quotes:
+ *  it is data, so it must never be treated as an executable or a matched
+ *  command word. */
+export type CommandToken = {
+    text: string;
+    opaque: boolean;
+};
+/** One shell segment: the raw text as the author wrote it, its leading
+ *  `VAR=value` assignments, and the remaining words — so `tokens[0]` is the
+ *  executable. An assignment-only segment (`export`-less `FOO=bar`) has
+ *  assignments and no tokens; the distinction matters, because a leading
+ *  assignment applies ONLY to the command in its own segment.
+ *
+ *  `background` marks a segment ended by a single `&`. It runs in a subshell,
+ *  so nothing it assigns or `cd`s reaches the commands after it. */
+export type CommandSegment = {
+    text: string;
+    assignments: string[];
+    tokens: CommandToken[];
+    background: boolean;
+};
+/** One raw segment and whether a single `&` — not `&&` — ended it. */
+export type RawSegment = {
+    text: string;
+    background: boolean;
+};
+/** Split a command into shell segments on unquoted `;`, newline, `&&`, `||`,
+ *  `|`, and a single `&`. Subshell parentheses and backticks are left inside
+ *  their segment. Heredoc bodies are a separate pre-read concern (see
+ *  `stripHeredocs`). */
+export declare function splitCommandSegments(command: string): RawSegment[];
+/** Tokenize one segment into shell words, marking quoted spans opaque. */
+export declare function tokenizeCommandSegment(segment: string): CommandToken[];
+/** Every non-empty command segment, paired with its raw text. */
+export declare function commandSegments(command: string): CommandSegment[];
+/** Remove heredoc BODIES (the stdin data between `<<DELIM` and its closing
+ *  `DELIM` line) from a command before it is read. The opening line is kept —
+ *  `crtr push final <<'EOF'` is still a real `push final` invocation — but the
+ *  body lines, which are data fed on stdin and never executed as commands, are
+ *  dropped. Without this, a doc-writing command whose body merely MENTIONS a
+ *  matched invocation would have its whole call held or refused. */
+export declare function stripHeredocs(command: string): string;

package/dist/core/shell-segments.js

@@ -0,0 +1,169 @@
+// shell-segments.ts — best-effort shell text reading, shared by everything in
+// crtr that has to reason about a command string it did not execute: the doc
+// substrate's `command`/`pre-command` surface matching and the bash valve's
+// refusals. Pure text in, structure out; no execution, no expansion.
+//
+// This is deliberately NOT a shell parser. Subshells, backticks, process
+// substitution, and path-prefixed binaries stay unhandled. Every caller must
+// treat a miss as "this text did not obviously do X", never as "this text
+// cannot do X".
+/** Split a command into shell segments on unquoted `;`, newline, `&&`, `||`,
+ *  `|`, and a single `&`. Subshell parentheses and backticks are left inside
+ *  their segment. Heredoc bodies are a separate pre-read concern (see
+ *  `stripHeredocs`). */
+export function splitCommandSegments(command) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    const finish = (background = false) => {
+        segments.push({ text: current, background });
+        current = '';
+    };
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && quote !== "'") {
+            current += ch;
+            escaped = true;
+            continue;
+        }
+        if (quote !== null) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            current += ch;
+            quote = ch;
+            continue;
+        }
+        if (ch === '\n' || ch === ';') {
+            finish();
+            continue;
+        }
+        if ((ch === '&' || ch === '|') && command[i + 1] === ch) {
+            finish();
+            i += 1;
+            continue;
+        }
+        if (ch === '|') {
+            finish();
+            continue;
+        }
+        if (ch === '&') {
+            finish(true);
+            continue;
+        }
+        current += ch;
+    }
+    finish();
+    return segments;
+}
+/** Tokenize one segment into shell words, marking quoted spans opaque. */
+export function tokenizeCommandSegment(segment) {
+    const tokens = [];
+    let text = '';
+    let opaque = false;
+    let started = false;
+    let quote = null;
+    let escaped = false;
+    const finish = () => {
+        if (started)
+            tokens.push({ text, opaque });
+        text = '';
+        opaque = false;
+        started = false;
+    };
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (escaped) {
+            text += ch;
+            started = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && quote !== "'") {
+            escaped = true;
+            started = true;
+            continue;
+        }
+        if (quote !== null) {
+            started = true;
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                text += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            opaque = true;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            finish();
+            continue;
+        }
+        text += ch;
+        started = true;
+    }
+    if (escaped)
+        text += '\\';
+    finish();
+    return tokens;
+}
+/** Every non-empty command segment, paired with its raw text. */
+export function commandSegments(command) {
+    return splitCommandSegments(command)
+        .map(({ text, background }) => {
+        const tokens = tokenizeCommandSegment(text);
+        let first = 0;
+        while (first < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[first].text))
+            first += 1;
+        return { text: text.trim(), assignments: tokens.slice(0, first).map((t) => t.text), tokens: tokens.slice(first), background };
+    })
+        .filter((segment) => segment.assignments.length > 0 || segment.tokens.length > 0);
+}
+const HEREDOC_OPEN = /<<(-?)\s*(["']?)([A-Za-z_][A-Za-z0-9_]*)\2/g;
+/** Remove heredoc BODIES (the stdin data between `<<DELIM` and its closing
+ *  `DELIM` line) from a command before it is read. The opening line is kept —
+ *  `crtr push final <<'EOF'` is still a real `push final` invocation — but the
+ *  body lines, which are data fed on stdin and never executed as commands, are
+ *  dropped. Without this, a doc-writing command whose body merely MENTIONS a
+ *  matched invocation would have its whole call held or refused. */
+export function stripHeredocs(command) {
+    const lines = command.split('\n');
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        out.push(line);
+        i += 1;
+        // Every heredoc opened on this line, left to right; their bodies stack and
+        // are consumed in that order.
+        const delims = [];
+        HEREDOC_OPEN.lastIndex = 0;
+        let m;
+        while ((m = HEREDOC_OPEN.exec(line)) !== null)
+            delims.push({ name: m[3], dash: m[1] === '-' });
+        for (const d of delims) {
+            while (i < lines.length) {
+                // `<<-` strips leading TABS from the body and the closing delimiter.
+                const probe = d.dash ? lines[i].replace(/^\t+/, '') : lines[i];
+                i += 1;
+                if (probe === d.name)
+                    break; // closing delimiter line — drop it, stop
+            }
+        }
+    }
+    return out.join('\n');
+}

package/dist/core/substrate/surface-match.d.ts

@@ -20,15 +20,6 @@ export declare function matchesReadEntry(entry: SurfaceEntry, doc: Pick<Substrat
 export declare function matchesMemoryReadEntry(entry: SurfaceEntry, routingAnchor: string, subject: NodeConfigSubject | null, name: string): boolean;
 /** Does a `command` entry fit the executed command string? */
 export declare function matchesCommandEntry(entry: SurfaceEntry, subject: NodeConfigSubject | null, command: string): boolean;
-/** Remove heredoc BODIES (the stdin data between `<<DELIM` and its closing
- *  `DELIM` line) from a command before it is matched. The opening line is kept
- *  — `crtr push final <<'EOF'` is still a real `push final` invocation — but the
- *  body lines, which are data fed on stdin and never executed as commands, are
- *  dropped. Without this a doc-writing command whose body merely MENTIONS a
- *  matched invocation would have its whole call held. Post-execution `command`
- *  delivery does not need this (a spurious late injection costs a paragraph);
- *  a `pre-command` block costs the agent a turn, so it does. */
-export declare function stripHeredocs(command: string): string;
 /** Does a `pre-command` entry fit a command that is ABOUT to run? The same
  *  glob machinery `command` uses — one matcher, one semantics — applied to the
  *  command with its heredoc bodies stripped. Subshell parentheses, backticks,