crewly 1.20.356 → 1.20.359

package/config/constants.ts

@@ -1155,6 +1155,17 @@ export const AGENT_SUSPEND_CONSTANTS = {
 	 * paid that 50 times a day on steamfun-ops (2026-09-16).
 	 */
 	CRON_KEEPALIVE_WINDOW_MINUTES: 30,
+	/**
+	 * An idle member that is in a conversation with the owner (an owner thread
+	 * the sentinel watches: the owner wrote to it, or it promised the owner
+	 * something, in the last two hours) is kept at least this long before an
+	 * idle stop, whatever the configured or pressure timeout says. Under the
+	 * 10-minute pressure timeout the audit of 2026-10-16 counted 50 idle stops
+	 * in 9 h, many of them agents the owner was still talking to; every stop
+	 * costs a cold start and, past the fresh-start threshold, the conversation
+	 * (crewly#1344). Memory-pressure and critical stops still apply.
+	 */
+	OWNER_THREAD_IDLE_TIMEOUT_MINUTES: 30,
 } as const;
 
 // ========================= SERVER PROCESS CONSTANTS =========================

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";
@@ -2050,6 +2051,178 @@ 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";
+};
+/**
+ * Automatic per-task work records (#1349): one `(record)` entry per finished
+ * WorkItem in the project vault log, compiled into the weekly digest.
+ */
+export declare const WORK_RECORD_CONSTANTS: {
+    /** Hourly tick: catch-up for finished items without a record, blocked items, deferred items. */
+    readonly TICK_MS: number;
+    /** Delay before the boot-time pass, after the other wiki jobs settled. */
+    readonly BOOT_DELAY_MS: number;
+    /** A terminal event waits this long before the record is assembled (ticket sync, verify item, evidence land first). */
+    readonly EVENT_DELAY_MS: number;
+    /** Catch-up looks at items that ended within this many days. */
+    readonly CATCHUP_WINDOW_DAYS: 7;
+    /** Cap on records written per pass (the rest wait for the next tick). */
+    readonly CATCHUP_MAX_PER_PASS: 200;
+    /** A record waiting for the owner's OK on a ticket is written anyway after this long. */
+    readonly DEFER_MAX_MS: number;
+    /** An item parked in `blocked` for longer than this gets a blocked record. */
+    readonly BLOCKED_AFTER_MS: number;
+    /** Hard cap on one record's body (the `meta:` line always fits). */
+    readonly MAX_CHARS: 2500;
+    /** Characters of the ask quoted. */
+    readonly QUOTE_MAX_CHARS: 160;
+    /** Characters of the result summary kept. */
+    readonly DID_MAX_CHARS: 400;
+    /** Cap on output lines and characters per line. */
+    readonly MAX_OUTPUTS: 8;
+    readonly OUTPUT_MAX_CHARS: 160;
+    /** Cap on error lines and characters per line. */
+    readonly MAX_ERRORS: 5;
+    readonly ERROR_MAX_CHARS: 160;
+    /** Cap on helper lines and characters per line. */
+    readonly MAX_HELPERS: 6;
+    readonly HELPER_MAX_CHARS: 120;
+    /** Bytes read from the end of the agent's transcript for the task window. */
+    readonly TRANSCRIPT_TAIL_BYTES: number;
+    /** Transcripts are consulted only for items that ended within this long (older windows are not in the tail). */
+    readonly TRANSCRIPT_MAX_AGE_MS: number;
+    /** Slack around the task window when slicing the transcript. */
+    readonly TRANSCRIPT_WINDOW_SLACK_MS: number;
+    /** Cap on trace events read per record. */
+    readonly TRACE_MAX_EVENTS: 2000;
+    /** State file (recorded keys), under CREWLY_HOME. */
+    readonly STATE_FILE: "work-records-state.json";
+    /** Cap on remembered record keys. */
+    readonly STATE_MAX_KEYS: 5000;
+    /** Kill switch env var; the value `false` disables work records. */
+    readonly ENV_KILL_SWITCH: "CREWLY_WORK_RECORDS";
+    /** Source type of a record entry in the vault log. */
+    readonly SOURCE_TYPE: "work_record";
+    /** Prefix of a record's `ref:` (`work-record:<workItemId>#<phase>`). */
+    readonly REF_PREFIX: "work-record:";
+    /** Records the startup briefing lists. */
+    readonly BRIEFING_MAX: 5;
+    /** Characters of one record line in the briefing. */
+    readonly BRIEFING_LINE_MAX_CHARS: 240;
+    /** WorkItem types that are bookkeeping, never recorded. */
+    readonly SKIPPED_TYPES: readonly string[];
+};
+/**
+ * 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,
@@ -2175,6 +2348,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;
     /**
@@ -2259,9 +2436,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;
     /**
@@ -2269,11 +2452,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";
     /**
@@ -3370,12 +3560,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 */
@@ -3385,7 +3587,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: {
@@ -3447,17 +3649,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 */
@@ -7149,6 +7377,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).
  */
@@ -7973,6 +8239,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
@@ -8347,6 +8626,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. */