crewly 1.20.355 → 1.20.358

package/dist/backend/backend/src/constants.d.ts

@@ -531,6 +531,7 @@ export declare const AGENT_SUSPEND_CONSTANTS: {
     readonly ALWAYS_ON_ROLES: readonly ["orchestrator", "auditor"];
     readonly AGENT_IDLE_STOP_TIMEOUT_MS: 1800000;
     readonly CRON_KEEPALIVE_WINDOW_MINUTES: 30;
+    readonly OWNER_THREAD_IDLE_TIMEOUT_MINUTES: 30;
 };
 export declare const VERSION_CHECK_CONSTANTS: {
     readonly NPM_REGISTRY_URL: "https://registry.npmjs.org/crewly/latest";
@@ -1885,6 +1886,19 @@ export declare const EVENT_BUS_CONSTANTS: {
      *  replayed publish of the same event is not delivered twice (#926) */
     readonly DELIVERED_EVENT_TTL_MS: number;
 };
+/**
+ * Recurring "TL progress check" scheduled by the team-leader delegate-task
+ * skill. Off by default (the lead is woken by the worker's agent:idle event
+ * and by report-status); an opted-in check never fires more often than
+ * MIN_INTERVAL_MINUTES. The 5-minute default woke Claude sessions 219 times
+ * in 3.5 days (2026-10-16).
+ */
+export declare const DELEGATION_PROGRESS_CHECK_CONSTANTS: {
+    /** Message prefix the skill uses; identifies these checks in the scheduler */
+    readonly MESSAGE_PREFIX: "TL progress check:";
+    /** Shortest allowed interval (minutes) for a recurring delegation progress check */
+    readonly MIN_INTERVAL_MINUTES: 30;
+};
 /**
  * Constants for Slack thread file storage.
  * Used by SlackThreadStoreService to persist thread conversations
@@ -2037,6 +2051,119 @@ export declare const WIKI_QUEUE_CONSTANTS: {
     readonly CLAIM_TIMEOUT_MS: number;
     /** Sub-folder of the queue root that holds expired items (kept, never deleted). */
     readonly DEAD_LETTER_DIR: "dead-letter";
+    /**
+     * Code drain (#1345): a pending item nobody claimed within this age is
+     * filed into the vault's `log.md` by the backend, without an LLM.
+     */
+    readonly DRAIN_MIN_AGE_MS: number;
+    /** Items filed per drain pass (the pass runs hourly, so a backlog of hundreds clears within a day). */
+    readonly DRAIN_BATCH_SIZE: 100;
+    /** Pause between two filed items, so a long backlog does not saturate disk I/O. */
+    readonly DRAIN_ITEM_PAUSE_MS: 25;
+    /** `claimedBy` / caller the drain stamps on items it files. */
+    readonly DRAIN_CLAIMANT: "system:wiki-queue-drain";
+};
+/**
+ * The vault activity log (`llm-curated/log.md`) and what the backend does
+ * with it (#1345): dedupe on append, rotation into an archive, recent
+ * entries in search, and a weekly digest page compiled from them.
+ */
+export declare const WIKI_LOG_CONSTANTS: {
+    /** Vault-relative path of the activity log. */
+    readonly LOG_RELATIVE_PATH: "llm-curated/log.md";
+    /** Vault-relative folder rotated logs move to (`log-YYYY-MM-DD.md`). Never read by search. */
+    readonly ARCHIVE_DIR: "llm-curated/log-archive";
+    /** Rotate when the log is larger than this. */
+    readonly ROTATE_MAX_BYTES: number;
+    /** Rotate when the log holds more entries than this. */
+    readonly ROTATE_MAX_ENTRIES: 2000;
+    /** After a rotation the fresh log keeps the non-noise entries from this many days. */
+    readonly CARRY_FORWARD_DAYS: 30;
+    /** Cap on entries carried into the fresh log. */
+    readonly CARRY_FORWARD_MAX_ENTRIES: 500;
+    /** Search/recall index the entries from this many days. */
+    readonly SEARCH_WINDOW_DAYS: 30;
+    /** Cap on log entries one vault contributes to a search. */
+    readonly SEARCH_MAX_ENTRIES_PER_VAULT: 300;
+    /** BM25 score multiplier for a log entry (pages rank above entries of equal relevance). */
+    readonly SEARCH_ENTRY_WEIGHT: 0.6;
+    /** Separator between the log path and an entry's timestamp in a search hit path. */
+    readonly ENTRY_PATH_SEPARATOR: "#";
+    /** Recent entry bodies remembered per vault to drop an identical append. */
+    readonly DEDUPE_RECENT_ENTRIES: 500;
+    /** Bytes of the log tail read once to seed the dedupe set. */
+    readonly DEDUPE_SEED_TAIL_BYTES: number;
+    /** The digest compiles the uncompiled non-noise entries from this many days. */
+    readonly COMPILE_WINDOW_DAYS: 7;
+    /** Fewer uncompiled entries than this: no digest page is written. */
+    readonly COMPILE_MIN_ENTRIES: 3;
+    /** Cap on entries one digest page takes (the rest wait for the next run). */
+    readonly COMPILE_MAX_ENTRIES: 150;
+    /** Characters of an entry body quoted in the digest. */
+    readonly COMPILE_ENTRY_MAX_CHARS: 400;
+    /** Vault-relative folder of digest pages. */
+    readonly COMPILE_DIR: "llm-curated/digests";
+    /** Vault-root file remembering which entries were compiled (dot-file: walkers skip it). */
+    readonly COMPILE_STATE_FILE: ".wiki-compile-state.json";
+    /** Cap on remembered compiled entry keys per vault. */
+    readonly COMPILE_STATE_MAX_KEYS: 5000;
+    /** Hourly maintenance tick (drain every tick; rotation + compile once per day). */
+    readonly MAINTENANCE_INTERVAL_MS: number;
+    /** Rotation + compile run at most this often. */
+    readonly MAINTENANCE_DAILY_MS: number;
+    /** Delay before the boot-time pass, so boot I/O settles first. */
+    readonly MAINTENANCE_BOOT_DELAY_MS: number;
+    /** Maintenance bookkeeping (last daily pass), under CREWLY_HOME. */
+    readonly MAINTENANCE_STATE_FILE: "wiki-maintenance-state.json";
+    /** Kill switch env var; the value `false` disables all wiki maintenance. */
+    readonly MAINTENANCE_ENV_KILL_SWITCH: "CREWLY_WIKI_MAINTENANCE";
+};
+/**
+ * Daily agent-memory refresh (#1345): what an agent recorded in the wiki
+ * log is reflected into its `memory.json` and the project's memory.
+ */
+export declare const AGENT_MEMORY_REFRESH_CONSTANTS: {
+    readonly INTERVAL_MS: number;
+    /** Delay before the boot-time catch-up run. */
+    readonly BOOT_DELAY_MS: number;
+    /** Entries newer than this are considered on the first run (later runs use the last-run watermark). */
+    readonly LOOKBACK_MS: number;
+    /** Cap on role-knowledge entries added per agent per run. */
+    readonly MAX_ENTRIES_PER_AGENT: 10;
+    /** Cap on characters of one entry kept as knowledge. */
+    readonly ENTRY_MAX_CHARS: 600;
+    /** Confidence of a knowledge entry derived from the agent's own log entries. */
+    readonly CONFIDENCE: 0.5;
+    /** State file (last run per agent), under CREWLY_HOME. */
+    readonly STATE_FILE: "agent-memory-refresh-state.json";
+    /** Kill switch env var; the value `false` disables the refresh. */
+    readonly ENV_KILL_SWITCH: "CREWLY_AGENT_MEMORY_REFRESH";
+};
+/**
+ * Startup briefing content (#1345): wiki pages, recent lessons and open
+ * owner threads an agent gets at registration, on top of its session memory.
+ */
+export declare const STARTUP_BRIEFING_CONSTANTS: {
+    /** Hard cap on the whole section. */
+    readonly MAX_CHARS: 12000;
+    /** Cap on the wiki index excerpt. */
+    readonly INDEX_MAX_CHARS: 4000;
+    /** Most-recently-changed topic pages listed. */
+    readonly RECENT_PAGES: 5;
+    /** Characters of a page summary shown. */
+    readonly PAGE_SUMMARY_MAX_CHARS: 240;
+    /** Lessons from this many days back. */
+    readonly LESSONS_DAYS: 7;
+    /** Cap on lessons listed. */
+    readonly LESSONS_MAX: 12;
+    /** Characters of one lesson shown. */
+    readonly LESSON_MAX_CHARS: 300;
+    /** Cap on owner threads listed. */
+    readonly THREADS_MAX: 5;
+    /** Characters of a thread preview shown. */
+    readonly THREAD_PREVIEW_MAX_CHARS: 160;
+    /** Section heading. */
+    readonly HEADING: "## Your Project Knowledge";
 };
 /**
  * Standing-answer pages (#816): a few question-anchored pages per scope,
@@ -2162,6 +2289,10 @@ export declare const SLACK_TYPING_CONSTANTS: {
     readonly TIMEOUT_TEXT: "⏱ {name} is still working on this — the reply will follow.";
     /** How long a placeholder waits for the reply before it is edited to TIMEOUT_TEXT */
     readonly TIMEOUT_MS: number;
+    /** Slack errors meaning the agent's bot cannot post in that channel at all (not a member of a private channel, or gone) */
+    readonly UNREACHABLE_CHANNEL_ERROR: RegExp;
+    /** After such an error, no placeholder is tried for that agent in that channel for this long (ms) */
+    readonly UNREACHABLE_CHANNEL_MS: number;
     /** A timed-out placeholder is still removed by a reply arriving within this long (ms) */
     readonly EXPIRED_KEEP_MS: number;
     /**
@@ -2246,9 +2377,15 @@ export declare const SLACK_THREAD_CONTEXT_CONSTANTS: {
     /** Whether the Slack context block is fetched at all */
     readonly ENABLED: true;
     /** Most messages shown (newest kept) */
-    readonly MAX_MESSAGES: 30;
-    /** Character budget of the whole block's message lines (newest kept) */
-    readonly MAX_CHARS: 5000;
+    readonly MAX_MESSAGES: 40;
+    /**
+     * Character budget of the whole block's message lines (newest kept).
+     * 5 000 → 12 000 (crewly#1344): with the thread root always shown and
+     * 1 500 characters per message, eight messages no longer fit in 5 000,
+     * and the owner approved the larger prompt over agents that could not see
+     * what the thread was about.
+     */
+    readonly MAX_CHARS: 12000;
     /** Characters kept per message before clipping */
     readonly PER_MESSAGE_CHARS: 4000;
     /**
@@ -2256,11 +2393,18 @@ export declare const SLACK_THREAD_CONTEXT_CONSTANTS: {
      * compact "thread so far", not a transcript: a 4 000-char draft pasted in
      * the thread made the prompt 13.5k chars, the busy-agent note cut it at
      * 6 000, and the newest posts and the owner's ping were the part cut
-     * (2026-10-08, #content-team).
+     * (2026-10-08, #content-team). 500 → 1 500 (crewly#1344): 500 cut most
+     * owner briefs mid-sentence; the busy-agent note now keeps the block's end.
      */
-    readonly BLOCK_PER_MESSAGE_CHARS: 500;
+    readonly BLOCK_PER_MESSAGE_CHARS: 1500;
     /** The block shows at least this many of the newest messages, or everything since the agent's own last post when that is more */
     readonly BLOCK_RECENT_MESSAGES: 8;
+    /**
+     * The thread's root message is always in the block, even when it is
+     * older than the window — it says what the thread is about (crewly#1344).
+     * Shown with this marker and a line saying how many messages were skipped.
+     */
+    readonly ROOT_MARK: "(thread root)";
     /** Marks a line addressed to the agent (or a person's post) after its last post in the thread */
     readonly UNANSWERED_MARK: "⟵ not answered by you yet";
     /**
@@ -3357,12 +3501,24 @@ export declare const ORC_CONVERSATION_CONSTANTS: {
     readonly FRESH_CONTEXT_TOKENS: 300000;
     /** How much of the old transcript's end is read to find the last turn's size */
     readonly TAIL_BYTES: number;
-    /** Messages kept in the handover file, newest last */
-    readonly HANDOVER_MESSAGES: 40;
+    /**
+     * Messages kept in the handover file, newest last. Raised 40 → 60 with
+     * the per-message and total caps (crewly#1344): a 16k-character tail of
+     * plain words lost the tool traffic entirely, and agents that were reset
+     * several times a day "remembered worse" than plain Claude Code.
+     */
+    readonly HANDOVER_MESSAGES: 60;
     /** Characters kept per handover message */
-    readonly HANDOVER_MESSAGE_CHARS: 800;
-    /** Total cap on the handover file's body */
-    readonly HANDOVER_MAX_CHARS: 16000;
+    readonly HANDOVER_MESSAGE_CHARS: 2000;
+    /** Total cap on the handover file's body (~40k characters, ~10k tokens) */
+    readonly HANDOVER_MAX_CHARS: 40000;
+    /**
+     * Characters kept of each tool call / tool result in a handover: the tool
+     * name plus the start of its input or output, one line each, so the new
+     * conversation knows WHAT was done (files read, commands run), not just
+     * what was said about it. Images stay a described placeholder.
+     */
+    readonly HANDOVER_TOOL_RESULT_CHARS: 200;
     /** Directory under CREWLY_HOME for handover files */
     readonly HANDOVER_DIR: "handover";
     /** A plain restart hands over the previous conversation only when its transcript was written within this window */
@@ -3372,7 +3528,7 @@ export declare const ORC_CONVERSATION_CONSTANTS: {
     /** How much of a transcript's start is read to check it belongs to a session (cwd-wide fallback) */
     readonly OWNERSHIP_HEAD_BYTES: number;
     /** Most of an earlier handover carried into a new one when the source conversation is unreadable */
-    readonly CHAINED_HANDOVER_MAX_CHARS: 16000;
+    readonly CHAINED_HANDOVER_MAX_CHARS: 40000;
 };
 /** Pointer header (open work, suggested skills) written at the top of a handover file. */
 export declare const HANDOVER_POINTERS_CONSTANTS: {
@@ -3434,17 +3590,43 @@ export declare const FRESH_TASK_CONVERSATION_CONSTANTS: {
     readonly NEW_SESSION_POLL_MS: 1000;
     /** Cap on the handover text stored through memory (mirrored into the wiki) */
     readonly MEMORY_MAX_CHARS: 4000;
-    /** Members start fresh at launch when their last turn carried this many tokens. Env: CREWLY_MEMBER_FRESH_CONTEXT_TOKENS */
-    readonly MEMBER_FRESH_CONTEXT_TOKENS: 150000;
+    /**
+     * Members start fresh at launch when their last turn carried this many
+     * tokens. Env: CREWLY_MEMBER_FRESH_CONTEXT_TOKENS.
+     *
+     * Above Claude Code's own auto-compact window (CLAUDE_CODE_CONTEXT, 350k)
+     * on purpose (crewly#1344): Claude compacts its conversation itself and
+     * keeps a far better summary than a handover tail, so Crewly's reset is
+     * only a safety net for a conversation that compaction did not bring
+     * down. At the old 150k the audit of 2026-10-16 counted 58 fresh starts
+     * in 48 h, every one of them replacing a live conversation with 16k
+     * characters of tail.
+     */
+    readonly MEMBER_FRESH_CONTEXT_TOKENS: 400000;
+    /**
+     * The smallest conversation a new-task `/clear` may close (last-turn
+     * tokens): the same as {@link MEMBER_FRESH_CONTEXT_TOKENS}, read through
+     * `memberFreshContextTokens()` so the env override applies to both. A
+     * conversation under it is cheap to keep and is what the agent remembers
+     * by; 137 clears in 48 h, some at 56k, were the cost of not having a floor.
+     */
+    readonly MIN_CLEAR_CONTEXT_TOKENS: 400000;
+    /**
+     * A member the owner spoke to this recently (an owner thread the sentinel
+     * watches: the owner's last message, or an open promise) is never cleared
+     * for a new task — the clear would wipe the conversation the owner is in.
+     */
+    readonly OWNER_CONVERSATION_ACTIVE_MS: number;
     /**
      * Idle-boundary context cap: a Claude Code member (never the orchestrator)
      * whose last turn carried more than this many tokens is saved (handover +
      * wiki) and cleared between turns, then re-oriented on its WorkItem. One
-     * long task can otherwise run 1000+ turns at 650k–965k context. Matches
-     * the 200k context ceiling the monitor alerts at, so a member never sits
-     * in "critical" between turns.
+     * long task can otherwise run 1000+ turns at 650k–965k context. Above the
+     * fresh-start threshold and Claude Code's 350k auto-compact (crewly#1344),
+     * so compaction runs first and this only catches a conversation that kept
+     * growing through it.
      */
-    readonly MEMBER_CONTEXT_CAP_TOKENS: 200000;
+    readonly MEMBER_CONTEXT_CAP_TOKENS: 450000;
     /** Env override for {@link MEMBER_CONTEXT_CAP_TOKENS}; `0` disables the cap */
     readonly MEMBER_CONTEXT_CAP_ENV: "CREWLY_MEMBER_CONTEXT_CAP_TOKENS";
     /** At most one context-cap clear per session in this window */
@@ -4209,6 +4391,8 @@ export declare const AGENT_MESSAGE_DELIVERY_CONSTANTS: {
 export declare const SUB_AGENT_QUEUE_CONSTANTS: {
     /** Wait this long after an agent goes down before waking it for its queued messages (ms) */
     readonly QUEUED_WAKE_DELAY_MS: 5000;
+    /** After boot, pause before starting agents that were down with messages queued (lets the restore queue claim its own first; a start in between drains the queue and ends the retry) */
+    readonly BOOT_QUEUED_WAKE_DELAY_MS: 60000;
     /** At most one such wake per agent in this window, so a crashing agent is not relaunched in a loop (ms) */
     readonly QUEUED_WAKE_COOLDOWN_MS: number;
     /** Maximum messages per agent before dropping oldest */
@@ -6998,6 +7182,10 @@ export declare const OPEN_ITEMS_CONSTANTS: {
     readonly ASK_OWNER_DEDUPE_WINDOW_MS: number;
     /** Two questions with at least this character-bigram overlap are the same question */
     readonly SAME_QUESTION_SIMILARITY: 0.5;
+    /** Window (ms) for counting an agent's lifted-question cards (#1334) */
+    readonly REPLY_CARD_WINDOW_MS: number;
+    /** At most this many lifted-question cards per agent per window; later questions are tracked without a card (#1334) */
+    readonly REPLY_CARDS_PER_AGENT_PER_DAY: 3;
     /** Option labels of a derived card */
     readonly YES_LABEL: "Yes";
     readonly NO_LABEL: "No";
@@ -7130,6 +7318,44 @@ export declare const TL_DELEGATION_CONSTANTS: {
     /** Accepted tool_name from the hook */
     readonly TOOL_NAME_PATTERN: RegExp;
 };
+/**
+ * Agent-to-agent coordination in Slack rooms (crewly#1340): local
+ * coordination stays inside Crewly, cross-machine coordination goes in a
+ * thread, ticket ids never reach Slack, near-identical repeats are dropped.
+ */
+export declare const AGENT_COORDINATION_CONSTANTS: {
+    /** chat-v2 message metadata: this agent post was delivered inside Crewly only (value: the reason) */
+    readonly INTERNAL_METADATA_KEY: "agentCoordinationInternal";
+    /** A repeat to the same recipients in the same room within this window is dropped (ms) */
+    readonly DUPLICATE_WINDOW_MS: number;
+    /** Character-bigram similarity at which two messages count as the same message */
+    readonly DUPLICATE_SIMILARITY: 0.85;
+    /** Messages remembered per sender/recipients/room */
+    readonly DUPLICATE_HISTORY: 10;
+    /** Sender/recipients/room keys remembered at most */
+    readonly DUPLICATE_MAX_KEYS: 500;
+    /** Request ticket prefix — always internal (`TKT-187`) */
+    readonly REQUEST_TICKET_PREFIX: "TKT";
+    /** Ticket prefixes are re-read at most this often (ms) */
+    readonly TICKET_PREFIX_CACHE_MS: number;
+    /** Who asked a helper is remembered this long, to hand back a reply it cannot post (ms) */
+    readonly ASKED_BY_TTL_MS: number;
+    /** Entries of the asked-by map at most */
+    readonly ASKED_BY_MAX: 500;
+    /** Longest wait for the directory when telling agents elsewhere from people (ms) */
+    readonly DIRECTORY_LOOKUP_MS: 2000;
+    /** Coordination threads (one per room per UTC day) remembered at most */
+    readonly COORDINATION_THREADS_MAX: 200;
+    /**
+     * Rules for every agent prompted from a Slack room. 2026-10-16: three
+     * agents on one machine flooded #content-team with top-level coordination,
+     * repeated one conclusion three times, quoted ticket ids, and promised to
+     * watch a log "every 3h".
+     */
+    readonly PROMPT_RULES: string;
+    /** Added when the message came from a colleague inside Crewly (never in Slack). */
+    readonly INTERNAL_PROMPT_LINE: "This message came from a colleague inside Crewly and is not in Slack: reply with the command above — your answer goes to them, not to the room.";
+};
 /**
  * Harness-owned reply routing (specs/2026-10-02-harness-owned-routing.md).
  */
@@ -7452,6 +7678,14 @@ export declare const RUNTIME_FALLBACK_CONSTANTS: {
     readonly TRANSIENT_ESCALATED_HORIZON_MS: number;
     /** A revert is not attempted while the PTY wrote within this window */
     readonly IDLE_QUIET_MS: 20000;
+    /**
+     * A session's model turn (a Claude Code PreToolUse hook) counts as proof that
+     * its runtime target has usage only this long after the target was marked out
+     * of usage (a response already streaming when the limit hit is not proof)
+     */
+    readonly WORKING_EVIDENCE_GRACE_MS: number;
+    /** Working-evidence reports of one session are looked at no more often than this */
+    readonly WORKING_EVIDENCE_THROTTLE_MS: 60000;
     /** Smoke tests */
     readonly SMOKE: {
         readonly TEAM_PREFIX: "zz-runtime-smoke-";
@@ -7471,6 +7705,44 @@ export declare const RUNTIME_FALLBACK_CONSTANTS: {
     /** Short names for "(Claude limit)" */
     readonly SHORT_LABELS: Readonly<Record<string, string>>;
 };
+/**
+ * Per-session usage-limit state (2026-10-16 incident: the orchestrator sat on
+ * Claude Code's weekly-limit menu for ~38 hours while Crewly restarted it,
+ * waited for its prompt, and reported it "active and ready"). While a session
+ * is usage-limited it is not restarted, not waited on and not written to.
+ */
+export declare const USAGE_LIMIT_STATE_CONSTANTS: {
+    /** How long to back off when the limit message names no reset time (ms) */
+    readonly NO_RESET_BACKOFF_MS: number;
+    /** Grace after the parsed reset time before the session is tried again (ms) */
+    readonly RESET_GRACE_MS: number;
+    /**
+     * Furthest a parsed reset time may lie ahead. Weekly limits reset within
+     * 7 days; a dated message further out is an old one (a past "Oct 10" is
+     * read as next year's), so it is not trusted.
+     */
+    readonly MAX_RESET_AHEAD_MS: number;
+    /** Trailing non-empty screen lines inspected for a usage-limit state */
+    readonly SCREEN_TAIL_LINES: 25;
+    /** Longest a held queue waits before looking at the state again (ms) */
+    readonly RECHECK_MAX_MS: 60000;
+    /** Delay between the keys that answer the usage-limit menu (ms) */
+    readonly MENU_KEY_DELAY_MS: 300;
+    /** Marker on a delivery result held because the agent is usage-limited */
+    readonly QUEUED_MARKER: "[USAGE_LIMITED]";
+    /**
+     * Fewest printable characters (whitespace collapsed) a live output chunk
+     * needs to count as fresh activity that lifts a usage-limit state; cursor
+     * moves and spinner ticks stay below it.
+     */
+    readonly FRESH_OUTPUT_MIN_CHARS: 40;
+    /**
+     * After a limit is last seen (or its menu answered), activity this soon is
+     * not trusted to lift the state: it is the repaint of the limit screen or
+     * of the key Crewly pressed (ms).
+     */
+    readonly LIFT_GRACE_MS: 10000;
+};
 /**
  * Per-person access (issue #968, epic #967): the people directory, the person
  * each agent turn acts for, and grant sharing. specs/per-person-access.md
@@ -7908,6 +8180,19 @@ export declare const OWNER_THREAD_SENTINEL_CONSTANTS: {
     readonly BOOT_CARD_MAX_AGE_MS: number;
     /** A card goes into an owner thread only when that thread was active this recently */
     readonly CARD_THREAD_MAX_AGE_MS: number;
+    /**
+     * A watched thread with no owner activity for this long is dropped at
+     * load and never counted as owed again (crewly#1344): a thread from 10-07
+     * whose owner last wrote on 10-08 was re-stamped "restarted" on every boot
+     * and listed as "work in hand" for ten days.
+     */
+    readonly STALE_AFTER_MS: number;
+    /**
+     * An agent counts as "in an owner conversation" while the owner wrote to
+     * it (or it promised the owner something) in a watched thread within this
+     * window — the per-task clear and the slot-cap eviction spare it (crewly#1344).
+     */
+    readonly OWNER_ACTIVE_MS: number;
 };
 /**
  * Drive mode briefing (specs/2026-10-08-drive-mode.md): the owner's queue of
@@ -8282,6 +8567,23 @@ export declare const TEAM_MOVE_CONSTANTS: {
     readonly NON_MACHINE_INSTANCE_PATTERN: "^crewly-cloud";
     /** Newest handover notes kept per agent. */
     readonly HANDOVERS_PER_AGENT: 10;
+    /**
+     * Largest Claude Code transcript (the agent's current conversation) that
+     * travels with a move, per agent (crewly#1344). Only the latest
+     * conversation per agent is packaged, under `transcripts/<session>/`, and
+     * resumed on the target; a bigger one is left behind and listed.
+     */
+    readonly TRANSCRIPT_MAX_BYTES: number;
+    /** Newest chat-v2 messages of the team's Slack room carried in the package (per channel). */
+    readonly CHAT_MESSAGES_PER_CHANNEL: 500;
+    /** Total cap on carried chat messages' content (bytes), all channels together. */
+    readonly CHAT_MESSAGES_MAX_BYTES: number;
+    /**
+     * Suffix of the folder a project is given on the target when the team
+     * lists a project the package did not carry: a clearly flagged placeholder
+     * the owner is told to re-point (never silently dropped, crewly#1344).
+     */
+    readonly PLACEHOLDER_PROJECT_SUFFIX: "-NEEDS-PATH";
     /** Largest text file that is path-rewritten and secret-scanned in memory. */
     readonly TEXT_FILE_MAX_BYTES: number;
     /** Free disk the target needs beyond the package (bytes): 2x package + this. */