crewly 1.20.356 → 1.20.359

package/dist/cli/backend/src/constants.js

@@ -1692,6 +1692,178 @@ export const WIKI_QUEUE_CONSTANTS = {
     CLAIM_TIMEOUT_MS: WIKI_QUEUE_DAY_MS,
     /** Sub-folder of the queue root that holds expired items (kept, never deleted). */
     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.
+     */
+    DRAIN_MIN_AGE_MS: WIKI_QUEUE_DAY_MS,
+    /** Items filed per drain pass (the pass runs hourly, so a backlog of hundreds clears within a day). */
+    DRAIN_BATCH_SIZE: 100,
+    /** Pause between two filed items, so a long backlog does not saturate disk I/O. */
+    DRAIN_ITEM_PAUSE_MS: 25,
+    /** `claimedBy` / caller the drain stamps on items it files. */
+    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 const WIKI_LOG_CONSTANTS = {
+    /** Vault-relative path of the activity log. */
+    LOG_RELATIVE_PATH: 'llm-curated/log.md',
+    /** Vault-relative folder rotated logs move to (`log-YYYY-MM-DD.md`). Never read by search. */
+    ARCHIVE_DIR: 'llm-curated/log-archive',
+    /** Rotate when the log is larger than this. */
+    ROTATE_MAX_BYTES: 2 * 1024 * 1024,
+    /** Rotate when the log holds more entries than this. */
+    ROTATE_MAX_ENTRIES: 2000,
+    /** After a rotation the fresh log keeps the non-noise entries from this many days. */
+    CARRY_FORWARD_DAYS: 30,
+    /** Cap on entries carried into the fresh log. */
+    CARRY_FORWARD_MAX_ENTRIES: 500,
+    /** Search/recall index the entries from this many days. */
+    SEARCH_WINDOW_DAYS: 30,
+    /** Cap on log entries one vault contributes to a search. */
+    SEARCH_MAX_ENTRIES_PER_VAULT: 300,
+    /** BM25 score multiplier for a log entry (pages rank above entries of equal relevance). */
+    SEARCH_ENTRY_WEIGHT: 0.6,
+    /** Separator between the log path and an entry's timestamp in a search hit path. */
+    ENTRY_PATH_SEPARATOR: '#',
+    /** Recent entry bodies remembered per vault to drop an identical append. */
+    DEDUPE_RECENT_ENTRIES: 500,
+    /** Bytes of the log tail read once to seed the dedupe set. */
+    DEDUPE_SEED_TAIL_BYTES: 256 * 1024,
+    /** The digest compiles the uncompiled non-noise entries from this many days. */
+    COMPILE_WINDOW_DAYS: 7,
+    /** Fewer uncompiled entries than this: no digest page is written. */
+    COMPILE_MIN_ENTRIES: 3,
+    /** Cap on entries one digest page takes (the rest wait for the next run). */
+    COMPILE_MAX_ENTRIES: 150,
+    /** Characters of an entry body quoted in the digest. */
+    COMPILE_ENTRY_MAX_CHARS: 400,
+    /** Vault-relative folder of digest pages. */
+    COMPILE_DIR: 'llm-curated/digests',
+    /** Vault-root file remembering which entries were compiled (dot-file: walkers skip it). */
+    COMPILE_STATE_FILE: '.wiki-compile-state.json',
+    /** Cap on remembered compiled entry keys per vault. */
+    COMPILE_STATE_MAX_KEYS: 5000,
+    /** Hourly maintenance tick (drain every tick; rotation + compile once per day). */
+    MAINTENANCE_INTERVAL_MS: 60 * 60 * 1000,
+    /** Rotation + compile run at most this often. */
+    MAINTENANCE_DAILY_MS: 24 * 60 * 60 * 1000,
+    /** Delay before the boot-time pass, so boot I/O settles first. */
+    MAINTENANCE_BOOT_DELAY_MS: 90 * 1000,
+    /** Maintenance bookkeeping (last daily pass), under CREWLY_HOME. */
+    MAINTENANCE_STATE_FILE: 'wiki-maintenance-state.json',
+    /** Kill switch env var; the value `false` disables all wiki maintenance. */
+    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 const AGENT_MEMORY_REFRESH_CONSTANTS = {
+    INTERVAL_MS: 24 * 60 * 60 * 1000,
+    /** Delay before the boot-time catch-up run. */
+    BOOT_DELAY_MS: 2 * 60 * 1000,
+    /** Entries newer than this are considered on the first run (later runs use the last-run watermark). */
+    LOOKBACK_MS: 24 * 60 * 60 * 1000,
+    /** Cap on role-knowledge entries added per agent per run. */
+    MAX_ENTRIES_PER_AGENT: 10,
+    /** Cap on characters of one entry kept as knowledge. */
+    ENTRY_MAX_CHARS: 600,
+    /** Confidence of a knowledge entry derived from the agent's own log entries. */
+    CONFIDENCE: 0.5,
+    /** State file (last run per agent), under CREWLY_HOME. */
+    STATE_FILE: 'agent-memory-refresh-state.json',
+    /** Kill switch env var; the value `false` disables the refresh. */
+    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 const WORK_RECORD_CONSTANTS = {
+    /** Hourly tick: catch-up for finished items without a record, blocked items, deferred items. */
+    TICK_MS: 60 * 60 * 1000,
+    /** Delay before the boot-time pass, after the other wiki jobs settled. */
+    BOOT_DELAY_MS: 3 * 60 * 1000,
+    /** A terminal event waits this long before the record is assembled (ticket sync, verify item, evidence land first). */
+    EVENT_DELAY_MS: 20 * 1000,
+    /** Catch-up looks at items that ended within this many days. */
+    CATCHUP_WINDOW_DAYS: 7,
+    /** Cap on records written per pass (the rest wait for the next tick). */
+    CATCHUP_MAX_PER_PASS: 200,
+    /** A record waiting for the owner's OK on a ticket is written anyway after this long. */
+    DEFER_MAX_MS: 72 * 60 * 60 * 1000,
+    /** An item parked in `blocked` for longer than this gets a blocked record. */
+    BLOCKED_AFTER_MS: 24 * 60 * 60 * 1000,
+    /** Hard cap on one record's body (the `meta:` line always fits). */
+    MAX_CHARS: 2_500,
+    /** Characters of the ask quoted. */
+    QUOTE_MAX_CHARS: 160,
+    /** Characters of the result summary kept. */
+    DID_MAX_CHARS: 400,
+    /** Cap on output lines and characters per line. */
+    MAX_OUTPUTS: 8,
+    OUTPUT_MAX_CHARS: 160,
+    /** Cap on error lines and characters per line. */
+    MAX_ERRORS: 5,
+    ERROR_MAX_CHARS: 160,
+    /** Cap on helper lines and characters per line. */
+    MAX_HELPERS: 6,
+    HELPER_MAX_CHARS: 120,
+    /** Bytes read from the end of the agent's transcript for the task window. */
+    TRANSCRIPT_TAIL_BYTES: 2 * 1024 * 1024,
+    /** Transcripts are consulted only for items that ended within this long (older windows are not in the tail). */
+    TRANSCRIPT_MAX_AGE_MS: 48 * 60 * 60 * 1000,
+    /** Slack around the task window when slicing the transcript. */
+    TRANSCRIPT_WINDOW_SLACK_MS: 60 * 1000,
+    /** Cap on trace events read per record. */
+    TRACE_MAX_EVENTS: 2_000,
+    /** State file (recorded keys), under CREWLY_HOME. */
+    STATE_FILE: 'work-records-state.json',
+    /** Cap on remembered record keys. */
+    STATE_MAX_KEYS: 5_000,
+    /** Kill switch env var; the value `false` disables work records. */
+    ENV_KILL_SWITCH: 'CREWLY_WORK_RECORDS',
+    /** Source type of a record entry in the vault log. */
+    SOURCE_TYPE: 'work_record',
+    /** Prefix of a record's `ref:` (`work-record:<workItemId>#<phase>`). */
+    REF_PREFIX: 'work-record:',
+    /** Records the startup briefing lists. */
+    BRIEFING_MAX: 5,
+    /** Characters of one record line in the briefing. */
+    BRIEFING_LINE_MAX_CHARS: 240,
+    /** WorkItem types that are bookkeeping, never recorded. */
+    SKIPPED_TYPES: ['check', 'reconcile', 'confirm', 'ticket_triage', 'autopilot_retro', 'goal_replan', 'ticket_hygiene_review', 'autopilot_self_review'],
+};
+/**
+ * Startup briefing content (#1345): wiki pages, recent lessons and open
+ * owner threads an agent gets at registration, on top of its session memory.
+ */
+export const STARTUP_BRIEFING_CONSTANTS = {
+    /** Hard cap on the whole section. */
+    MAX_CHARS: 12_000,
+    /** Cap on the wiki index excerpt. */
+    INDEX_MAX_CHARS: 4_000,
+    /** Most-recently-changed topic pages listed. */
+    RECENT_PAGES: 5,
+    /** Characters of a page summary shown. */
+    PAGE_SUMMARY_MAX_CHARS: 240,
+    /** Lessons from this many days back. */
+    LESSONS_DAYS: 7,
+    /** Cap on lessons listed. */
+    LESSONS_MAX: 12,
+    /** Characters of one lesson shown. */
+    LESSON_MAX_CHARS: 300,
+    /** Cap on owner threads listed. */
+    THREADS_MAX: 5,
+    /** Characters of a thread preview shown. */
+    THREAD_PREVIEW_MAX_CHARS: 160,
+    /** Section heading. */
+    HEADING: '## Your Project Knowledge',
 };
 /**
  * Standing-answer pages (#816): a few question-anchored pages per scope,
@@ -1818,6 +1990,10 @@ export const SLACK_TYPING_CONSTANTS = {
     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 */
     TIMEOUT_MS: 5 * 60 * 1000,
+    /** Slack errors meaning the agent's bot cannot post in that channel at all (not a member of a private channel, or gone) */
+    UNREACHABLE_CHANNEL_ERROR: /\b(channel_not_found|not_in_channel|is_archived)\b/,
+    /** After such an error, no placeholder is tried for that agent in that channel for this long (ms) */
+    UNREACHABLE_CHANNEL_MS: 60 * 60 * 1000,
     /** A timed-out placeholder is still removed by a reply arriving within this long (ms) */
     EXPIRED_KEEP_MS: 24 * 60 * 60 * 1000,
     /**
@@ -1902,9 +2078,15 @@ export const SLACK_THREAD_CONTEXT_CONSTANTS = {
     /** Whether the Slack context block is fetched at all */
     ENABLED: true,
     /** Most messages shown (newest kept) */
-    MAX_MESSAGES: 30,
-    /** Character budget of the whole block's message lines (newest kept) */
-    MAX_CHARS: 5_000,
+    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.
+     */
+    MAX_CHARS: 12_000,
     /** Characters kept per message before clipping */
     PER_MESSAGE_CHARS: 4_000,
     /**
@@ -1912,11 +2094,18 @@ export 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.
      */
-    BLOCK_PER_MESSAGE_CHARS: 500,
+    BLOCK_PER_MESSAGE_CHARS: 1_500,
     /** The block shows at least this many of the newest messages, or everything since the agent's own last post when that is more */
     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.
+     */
+    ROOT_MARK: '(thread root)',
     /** Marks a line addressed to the agent (or a person's post) after its last post in the thread */
     UNANSWERED_MARK: '⟵ not answered by you yet',
     /**
@@ -3092,12 +3281,24 @@ export const ORC_CONVERSATION_CONSTANTS = {
     FRESH_CONTEXT_TOKENS: 300_000,
     /** How much of the old transcript's end is read to find the last turn's size */
     TAIL_BYTES: 2 * 1024 * 1024,
-    /** Messages kept in the handover file, newest last */
-    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.
+     */
+    HANDOVER_MESSAGES: 60,
     /** Characters kept per handover message */
-    HANDOVER_MESSAGE_CHARS: 800,
-    /** Total cap on the handover file's body */
-    HANDOVER_MAX_CHARS: 16_000,
+    HANDOVER_MESSAGE_CHARS: 2_000,
+    /** Total cap on the handover file's body (~40k characters, ~10k tokens) */
+    HANDOVER_MAX_CHARS: 40_000,
+    /**
+     * 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.
+     */
+    HANDOVER_TOOL_RESULT_CHARS: 200,
     /** Directory under CREWLY_HOME for handover files */
     HANDOVER_DIR: 'handover',
     /** A plain restart hands over the previous conversation only when its transcript was written within this window */
@@ -3107,7 +3308,7 @@ export const ORC_CONVERSATION_CONSTANTS = {
     /** How much of a transcript's start is read to check it belongs to a session (cwd-wide fallback) */
     OWNERSHIP_HEAD_BYTES: 256 * 1024,
     /** Most of an earlier handover carried into a new one when the source conversation is unreadable */
-    CHAINED_HANDOVER_MAX_CHARS: 16_000,
+    CHAINED_HANDOVER_MAX_CHARS: 40_000,
 };
 /** Pointer header (open work, suggested skills) written at the top of a handover file. */
 export const HANDOVER_POINTERS_CONSTANTS = {
@@ -3169,17 +3370,43 @@ export const FRESH_TASK_CONVERSATION_CONSTANTS = {
     NEW_SESSION_POLL_MS: 1_000,
     /** Cap on the handover text stored through memory (mirrored into the wiki) */
     MEMORY_MAX_CHARS: 4_000,
-    /** Members start fresh at launch when their last turn carried this many tokens. Env: CREWLY_MEMBER_FRESH_CONTEXT_TOKENS */
-    MEMBER_FRESH_CONTEXT_TOKENS: 150_000,
+    /**
+     * 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.
+     */
+    MEMBER_FRESH_CONTEXT_TOKENS: 400_000,
+    /**
+     * 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.
+     */
+    MIN_CLEAR_CONTEXT_TOKENS: 400_000,
+    /**
+     * 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.
+     */
+    OWNER_CONVERSATION_ACTIVE_MS: 2 * 60 * 60 * 1000,
     /**
      * 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.
      */
-    MEMBER_CONTEXT_CAP_TOKENS: 200_000,
+    MEMBER_CONTEXT_CAP_TOKENS: 450_000,
     /** Env override for {@link MEMBER_CONTEXT_CAP_TOKENS}; `0` disables the cap */
     MEMBER_CONTEXT_CAP_ENV: 'CREWLY_MEMBER_CONTEXT_CAP_TOKENS',
     /** At most one context-cap clear per session in this window */
@@ -7065,6 +7292,48 @@ export const TL_DELEGATION_CONSTANTS = {
     /** Accepted tool_name from the hook */
     TOOL_NAME_PATTERN: /^[A-Za-z0-9_-]{1,64}$/,
 };
+/**
+ * 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 const AGENT_COORDINATION_CONSTANTS = {
+    /** chat-v2 message metadata: this agent post was delivered inside Crewly only (value: the reason) */
+    INTERNAL_METADATA_KEY: 'agentCoordinationInternal',
+    /** A repeat to the same recipients in the same room within this window is dropped (ms) */
+    DUPLICATE_WINDOW_MS: 15 * 60 * 1000,
+    /** Character-bigram similarity at which two messages count as the same message */
+    DUPLICATE_SIMILARITY: 0.85,
+    /** Messages remembered per sender/recipients/room */
+    DUPLICATE_HISTORY: 10,
+    /** Sender/recipients/room keys remembered at most */
+    DUPLICATE_MAX_KEYS: 500,
+    /** Request ticket prefix — always internal (`TKT-187`) */
+    REQUEST_TICKET_PREFIX: 'TKT',
+    /** Ticket prefixes are re-read at most this often (ms) */
+    TICKET_PREFIX_CACHE_MS: 10 * 60 * 1000,
+    /** Who asked a helper is remembered this long, to hand back a reply it cannot post (ms) */
+    ASKED_BY_TTL_MS: 6 * 60 * 60 * 1000,
+    /** Entries of the asked-by map at most */
+    ASKED_BY_MAX: 500,
+    /** Longest wait for the directory when telling agents elsewhere from people (ms) */
+    DIRECTORY_LOOKUP_MS: 2000,
+    /** Coordination threads (one per room per UTC day) remembered at most */
+    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".
+     */
+    PROMPT_RULES: 'Working with colleagues: when you need a colleague\'s help, @ them — if everyone you @ is an agent on this machine, it reaches them inside Crewly and is not posted to Slack. ' +
+        'Helpers answer whoever asked them, not the room; the agent the room asked posts one consolidated update in the original thread once the result is in. ' +
+        'Do not resend an answer you already gave the same colleague — point to it in one line. ' +
+        'Never promise to poll or watch something periodically ("I\'ll check the log every 3h"): ask to be pinged, or rely on the event that tells you. ' +
+        'Ticket ids (e.g. CREW-12) and ticket mechanics are internal: never write them in anything people read.',
+    /** Added when the message came from a colleague inside Crewly (never in Slack). */
+    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).
  */
@@ -7923,6 +8192,19 @@ export const OWNER_THREAD_SENTINEL_CONSTANTS = {
     BOOT_CARD_MAX_AGE_MS: 24 * 60 * 60 * 1000,
     /** A card goes into an owner thread only when that thread was active this recently */
     CARD_THREAD_MAX_AGE_MS: 2 * 60 * 60 * 1000,
+    /**
+     * 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.
+     */
+    STALE_AFTER_MS: 3 * 24 * 60 * 60 * 1000,
+    /**
+     * 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).
+     */
+    OWNER_ACTIVE_MS: 2 * 60 * 60 * 1000,
 };
 /**
  * Drive mode briefing (specs/2026-10-08-drive-mode.md): the owner's queue of
@@ -8282,6 +8564,23 @@ export const TEAM_MOVE_CONSTANTS = {
     NON_MACHINE_INSTANCE_PATTERN: '^crewly-cloud',
     /** Newest handover notes kept per agent. */
     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.
+     */
+    TRANSCRIPT_MAX_BYTES: 64 * 1024 * 1024,
+    /** Newest chat-v2 messages of the team's Slack room carried in the package (per channel). */
+    CHAT_MESSAGES_PER_CHANNEL: 500,
+    /** Total cap on carried chat messages' content (bytes), all channels together. */
+    CHAT_MESSAGES_MAX_BYTES: 4 * 1024 * 1024,
+    /**
+     * 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).
+     */
+    PLACEHOLDER_PROJECT_SUFFIX: '-NEEDS-PATH',
     /** Largest text file that is path-rewritten and secret-scanned in memory. */
     TEXT_FILE_MAX_BYTES: 8 * 1024 * 1024,
     /** Free disk the target needs beyond the package (bytes): 2x package + this. */