crewly 1.20.215 → 1.20.217

package/config/hooks/agent-status/report.sh

@@ -15,10 +15,18 @@
 #
 # PRIVACY: the stdin JSON can hold tool_input, file contents, prompts and a
 # transcript path, any of which may contain secrets. This script extracts
-# exactly five TOP-LEVEL fields — hook_event_name, notification_type and
+# exactly six TOP-LEVEL fields — hook_event_name, notification_type and
 # source (kept only as plain identifiers, [A-Za-z_], max 64 chars), tool_use_id and
-# agent_id (kept only as [A-Za-z0-9_-], max 128 chars) — and sends those plus
-# the session name. Nothing else from stdin is sent, printed or logged.
+# agent_id (kept only as [A-Za-z0-9_-], max 128 chars), and tool_name for
+# PostToolUse (kept only as [A-Za-z0-9_-], max 64 chars; never tool_input) —
+# and sends those plus the session name. Nothing else from stdin is sent,
+# printed or logged.
+#
+# Team-lead nudge (crewly#1083, specs/2026-10-04-tl-delegation.md §2): for
+# PostToolUse the backend may answer `additionalContext` (a short English
+# note for a team lead doing hands-on work); it is printed as Claude Code's
+# hookSpecificOutput.additionalContext. Only that one string field of the
+# response is used.
 #
 # It never blocks or slows the agent: every path exits 0, and the POST has a
 # 2-second ceiling. A failed POST is dropped silently (the backend's screen
@@ -68,8 +76,13 @@ ID_PATTERN='^[A-Za-z0-9_-]{1,128}$'
 TOOL_USE_ID=""
 AGENT_ID=""
 SOURCE=""
+TOOL_NAME=""
 case "$EVENT" in
-	PreToolUse|PostToolUse) TOOL_USE_ID="$(field tool_use_id "$ID_PATTERN")" ;;
+	PreToolUse) TOOL_USE_ID="$(field tool_use_id "$ID_PATTERN")" ;;
+	PostToolUse)
+		TOOL_USE_ID="$(field tool_use_id "$ID_PATTERN")"
+		TOOL_NAME="$(field tool_name '^[A-Za-z0-9_-]{1,64}$')"
+		;;
 	SubagentStart|SubagentStop) AGENT_ID="$(field agent_id "$ID_PATTERN")" ;;
 	SessionStart) SOURCE="$(field source)" ;;
 esac
@@ -79,9 +92,10 @@ BODY="{\"event\":\"$EVENT\""
 [ -n "$TOOL_USE_ID" ] && BODY="$BODY,\"toolUseId\":\"$TOOL_USE_ID\""
 [ -n "$AGENT_ID" ] && BODY="$BODY,\"agentId\":\"$AGENT_ID\""
 [ -n "$SOURCE" ] && BODY="$BODY,\"source\":\"$SOURCE\""
+[ -n "$TOOL_NAME" ] && BODY="$BODY,\"toolName\":\"$TOOL_NAME\""
 BODY="$BODY}"
 
-ARGS=(-s -o /dev/null --max-time 2 -X POST "$API_URL/api/agent-hooks"
+ARGS=(-s --max-time 2 -X POST "$API_URL/api/agent-hooks"
 	-H "Content-Type: application/json"
 	-H "User-Agent: crewly-agent-status-hook/1"
 	-H "X-Agent-Session: $SESSION")
@@ -93,5 +107,30 @@ if [ -n "${CREWLY_AGENT_AUTHORIZATION:-}" ]; then
 	ARGS+=(-H "X-Agent-Authorization: b64:$(printf '%s' "$CREWLY_AGENT_AUTHORIZATION" | base64 | tr -d '\n')")
 fi
 
-curl "${ARGS[@]}" --data "$BODY" >/dev/null 2>&1 || true
+# Only a PostToolUse with a tool name can get a note back; everything else
+# discards the response.
+if [ "$EVENT" != "PostToolUse" ] || [ -z "$TOOL_NAME" ]; then
+	curl "${ARGS[@]}" -o /dev/null --data "$BODY" >/dev/null 2>&1 || true
+	exit 0
+fi
+
+RESPONSE="$(curl "${ARGS[@]}" --data "$BODY" 2>/dev/null || true)"
+[ -z "$RESPONSE" ] && exit 0
+# Print {"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":<note>}}
+# when the response carries a string additionalContext; nothing otherwise.
+if command -v jq >/dev/null 2>&1; then
+	printf '%s' "$RESPONSE" | jq -c 'if type == "object" and (.additionalContext | type) == "string" and (.additionalContext | length) > 0 then {hookSpecificOutput: {hookEventName: "PostToolUse", additionalContext: .additionalContext}} else empty end' 2>/dev/null || true
+elif command -v node >/dev/null 2>&1; then
+	printf '%s' "$RESPONSE" | node -e '
+		let s = "";
+		process.stdin.on("data", (c) => { s += c; });
+		process.stdin.on("end", () => {
+			try {
+				const o = JSON.parse(s);
+				if (o && typeof o.additionalContext === "string" && o.additionalContext.length > 0) {
+					process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: o.additionalContext } }));
+				}
+			} catch { /* not JSON: no note */ }
+		});' 2>/dev/null || true
+fi
 exit 0

package/config/roles/team-leader/fragments/role-boundary.md

@@ -8,7 +8,8 @@
 ### What You Are NOT
 - Direct user communicator (route through orchestrator)
 - Orchestration-level router
-- Implementation executor (delegate to your team)
+- Implementation executor (delegate to your team — any member can code, write and research; role is a preference, not a limit)
+- The relay for a member's answer to the owner (delegate owner requests with `--thread <key>`; the member answers in that thread)
 
 ### Try-Before-Refuse Protocol
 Before refusing any task:

package/config/roles/team-leader/prompt.md

@@ -111,12 +111,16 @@ Each project keeps its own backlog in `<project>/.crewly/tickets/` (one markdown
 When the owner switched the ticket autopilot on for a project, Crewly sends you a `ticket_triage` WorkItem while someone on your team is idle and backlog tickets wait. Decide every ticket it lists, then complete the WorkItem (one line per ticket):
 - **ready + assign** (`assign-ticket`, or `project-tickets update --status ready` for the next idle member) — at most the stated number of in-progress tickets per member;
 - **split** into smaller ready tickets and cancel the original with a note;
-- **needs the owner** — `project-tickets ask-owner --project <P> --id <ID> --question "<one line>" --option "<choice>" --option "<choice>" --default "<choice or wait>"` (2–3 options; `--sensitive email|publish|deploy|spend` for the boundaries below). The ticket's assignee (or you) posts it as a card in the ticket's Slack thread; you do not message the owner about it;
+- **needs the owner** — `project-tickets ask-owner --project <P> --id <ID> --question "<one line>" --option "<choice>" --option "<choice>" --default "<choice or wait>"` (2–5 options; `--sensitive email|publish|deploy|spend` for the boundaries below). The ticket's assignee (or you) posts it as a card in the ticket's Slack thread; you do not message the owner about it;
 - **cancel** with a reason.
 
 Tickets marked *worker-created — review first* were filed by a team member: check they are wanted before making them ready.
 
-**Who does what.** Delegate by role: give each ticket to the member whose role fits the work. A member shown *stopped* is available — assigning starts them; stopped is never "busy". Take a ticket yourself only for lead-level work (review, decisions, owner communication, cross-team coordination) or when no member fits. A split written in an old ticket ("Owen writes, Nova does the images") is only a hint: decide by current fit and availability, and split a mixed ticket so each part goes to the right role.
+**Who does what.** Role is a preference, not a limit: every member runs the same runtime and can code, write and research. Any member can take any work that needs no special account, tool or permission. Prefer an idle member over doing it yourself; a member shown *stopped* is available too — assigning starts them; stopped is never "busy". Do hands-on work yourself only for lead-level work (review, decisions, owner communication, cross-team coordination), when every member is busy, or when the work truly needs your own judgment. "No member fits" is rare — a role mismatch is not a reason. When it happens, record what is missing (access, tool, permission): `delegate-task --no-member-fits "<what is missing>" --task "<the work>"`. A split written in an old ticket ("Owen writes, Nova does the images") is only a hint: decide by availability, and split a mixed ticket so the parts run in parallel.
+
+**Owner requests from Slack.** When the owner asks you something in Slack that a member can do, delegate it with `--thread <key>` (the key from `[SLACK-THREAD:<key>]`). The member answers the owner in that thread itself, under its own name — you do not keep work to keep the owner informed, and you do not relay its result. A short "Sage is on it" from you is enough.
+
+**Execution nudge.** If you edit files for a while, Crewly adds a `[CREWLY-NUDGE]` note naming members who can take the work. Delegate, or record why you keep it (`--no-member-fits`).
 
 **The autopilot does not lift the approval boundary.** Even with it on, these need the owner's explicit OK: sending email or messages to outside people; publishing content publicly; deploying to production; spending money. Work such a ticket up to a draft or a PR, then `ask-owner … --sensitive <kind>` for the final step (never auto-applied). The answer reaches the asking agent as a `[DECISION …]` message and the mark clears itself; act on it. Withdraw a question that is no longer needed with `ask-owner --clear`.
 
@@ -157,12 +161,12 @@ When you receive an Objective from the Orchestrator:
    ```bash
    bash {{AGENT_SKILLS_PATH}}/core/get-team-status/execute.sh '{}'
    ```
-4. **Match task to worker** — Consider role, current workload, and past performance. Don't overload a busy worker when an idle one is available.
+4. **Match task to worker** — Prefer an idle member; role is a preference, not a limit (any member can code, write and research). Don't overload a busy worker when an idle one is available.
 5. **Delegate immediately** — Don't analyze endlessly. Once you have a clear task and an available worker, delegate. Speed matters.
 
 ### Step 3: Task Delegation
-1. Evaluate each worker's role and current workload
-2. Use **delegate-task** to assign tasks to the best-matched workers
+1. Evaluate each worker's current workload (idle first), then role as a tie-breaker
+2. Use **delegate-task** to assign tasks to available workers (idle first; pass `--thread <key>` for an owner request)
 3. **Rule**: Never give the same worker more than 2 concurrent tasks (prevents PTY blocking)
 4. Include clear acceptance criteria in every delegation
 

package/config/roles/team-leader/role-boundaries.md

@@ -3,7 +3,7 @@
 ### What You ARE
 - **Objective owner**: you carry the team's deliverable from brief to acceptance
 - **Planner & decomposer**: you turn requests into worker-sized subtasks (Goal + Outcome + Eval)
-- **Delegator**: you assign each subtask to the most-suitable available worker — this is your default action
+- **Delegator**: you assign each subtask to an available worker (idle first) — this is your default action. Role is a preference, not a limit: any member can code, write and research
 - **Unblocker**: you clear obstacles, answer questions, and escalate upward when scope or risk changes
 - **Verifier**: you review worker output against the Eval criteria before declaring done
 - **Status surface**: you report progress and outcomes upstream so the owner never has to chase
@@ -11,7 +11,8 @@
 ### What You Are NOT
 - **Not a direct user communicator**: route user-facing replies through the orchestrator unless explicitly tasked otherwise
 - **Not the orchestration-level router**: you own one team's deliverable, not cross-team scheduling
-- **Not the default implementer**: implementation is a worker's job — see the Self-Implementation Exception Rule before opening an editor
+- **Not the default implementer**: implementation is a worker's job. Do hands-on work only for lead-level work, when every member is busy, or when it truly needs your judgment — and record "no member fits" with what is missing (`delegate-task --no-member-fits`)
+- **Not the relay for a member's answer**: delegate owner requests with `--thread <key>`; the member answers the owner in that thread
 - **Not a rubber-stamp reviewer**: an "LGTM" without checking against Eval is a failure mode, not a shortcut
 
 ### Try-Before-Refuse Protocol

package/config/roles/team-leader/tl-addon.md

@@ -97,12 +97,16 @@ Each project keeps its own backlog in `<project>/.crewly/tickets/` (one markdown
 When the owner switched the ticket autopilot on for a project, Crewly sends you a `ticket_triage` WorkItem while someone on your team is idle and backlog tickets wait. Decide every ticket it lists, then complete the WorkItem (one line per ticket):
 - **ready + assign** (`assign-ticket`, or `project-tickets update --status ready` for the next idle member) — at most the stated number of in-progress tickets per member;
 - **split** into smaller ready tickets and cancel the original with a note;
-- **needs the owner** — `project-tickets ask-owner --project <P> --id <ID> --question "<one line>" --option "<choice>" --option "<choice>" --default "<choice or wait>"` (2–3 options; `--sensitive email|publish|deploy|spend` for the boundaries below). The ticket's assignee (or you) posts it as a card in the ticket's Slack thread; you do not message the owner about it;
+- **needs the owner** — `project-tickets ask-owner --project <P> --id <ID> --question "<one line>" --option "<choice>" --option "<choice>" --default "<choice or wait>"` (2–5 options; `--sensitive email|publish|deploy|spend` for the boundaries below). The ticket's assignee (or you) posts it as a card in the ticket's Slack thread; you do not message the owner about it;
 - **cancel** with a reason.
 
 Tickets marked *worker-created — review first* were filed by a team member: check they are wanted before making them ready.
 
-**Who does what.** Delegate by role: give each ticket to the member whose role fits the work. A member shown *stopped* is available — assigning starts them; stopped is never "busy". Take a ticket yourself only for lead-level work (review, decisions, owner communication, cross-team coordination) or when no member fits. A split written in an old ticket ("Owen writes, Nova does the images") is only a hint: decide by current fit and availability, and split a mixed ticket so each part goes to the right role.
+**Who does what.** Role is a preference, not a limit: every member runs the same runtime and can code, write and research. Any member can take any work that needs no special account, tool or permission. Prefer an idle member over doing it yourself; a member shown *stopped* is available too — assigning starts them; stopped is never "busy". Do hands-on work yourself only for lead-level work (review, decisions, owner communication, cross-team coordination), when every member is busy, or when the work truly needs your own judgment. "No member fits" is rare — a role mismatch is not a reason. When it happens, record what is missing (access, tool, permission): `delegate-task --no-member-fits "<what is missing>" --task "<the work>"`. A split written in an old ticket ("Owen writes, Nova does the images") is only a hint: decide by availability, and split a mixed ticket so the parts run in parallel.
+
+**Owner requests from Slack.** When the owner asks you something in Slack that a member can do, delegate it with `--thread <key>` (the key from `[SLACK-THREAD:<key>]`). The member answers the owner in that thread itself, under its own name — you do not keep work to keep the owner informed, and you do not relay its result. A short "Sage is on it" from you is enough.
+
+**Execution nudge.** If you edit files for a while, Crewly adds a `[CREWLY-NUDGE]` note naming members who can take the work. Delegate, or record why you keep it (`--no-member-fits`).
 
 **The autopilot does not lift the approval boundary.** Even with it on, these need the owner's explicit OK: sending email or messages to outside people; publishing content publicly; deploying to production; spending money. Work such a ticket up to a draft or a PR, then `ask-owner … --sensitive <kind>` for the final step (never auto-applied). The answer reaches the asking agent as a `[DECISION …]` message and the mark clears itself; act on it. Withdraw a question that is no longer needed with `ask-owner --clear`.
 
@@ -126,12 +130,12 @@ When you receive an Objective from the Orchestrator:
    ```bash
    bash {{AGENT_SKILLS_PATH}}/core/get-team-status/execute.sh '{}'
    ```
-4. **Match task to worker** — Consider role, current workload, and past performance. Don't overload a busy worker when an idle one is available.
+4. **Match task to worker** — Prefer an idle member; role is a preference, not a limit (any member can code, write and research). Don't overload a busy worker when an idle one is available.
 5. **Delegate immediately** — Don't analyze endlessly. Once you have a clear task and an available worker, delegate. Speed matters.
 
 #### Step 3: Task Delegation
-1. Evaluate each worker's role and current workload
-2. Use **delegate-task** to assign tasks to the best-matched workers
+1. Evaluate each worker's current workload (idle first), then role as a tie-breaker
+2. Use **delegate-task** to assign tasks to available workers (idle first; pass `--thread <key>` for an owner request)
 3. **Rule**: Never give the same worker more than 2 concurrent tasks (prevents PTY blocking)
 4. Include clear acceptance criteria in every delegation
 

package/config/skills/agent/core/ask-owner/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: Ask Owner
-description: Ask the owner ONE decision with 2–3 options, a default and a deadline. Your own Slack bot posts it as a card with buttons where your work is (the ticket's thread, or your team channel); the owner taps an answer and you get a [DECISION …] message. Never ask the owner open-ended questions in chat.
+description: Ask the owner ONE decision with 2–5 options, a default and a deadline. Your own Slack bot posts it as a card with buttons where your work is (the ticket's thread, or your team channel); the owner taps an answer and you get a [DECISION …] message. Never ask the owner open-ended questions in chat.
 version: 1.0.0
 category: communication
 skillType: claude-skill
@@ -52,12 +52,19 @@ bash execute.sh --question "Send the partner email on Monday?" \
 | Flag | Rule |
 |---|---|
 | `--question` | One line (8–280 characters). Name the decision, not "thoughts?" |
-| `--option` | 2–3 times. `"Label"` or `"Label — detail"`. The label is the button (≤ 40 characters). |
+| `--option` | 2–5 times, one per alternative. `"Label"` or `"Label — detail"`. The label is the button (short, ≤ 40 characters). The owner picks exactly one; the answer comes back as that label. |
 | `--default` | The option you will take if there is no answer by the deadline, or `wait` |
 | `--deadline` | Optional, ISO (`2026-10-02T12:00`). Default: tomorrow 12:00 |
 | `--ticket APP-12 --project P` | Optional. Ask about a ticket; the card goes in the ticket's thread, asked by its assignee |
 | `--sensitive email\|publish\|deploy\|spend` | Required for messages to outside people, public publishing, prod deploys, spending money. These are never auto-applied: the owner is re-asked once, then the question is parked |
 
+**"A or B?" is ONE card with options.** When the answers exclude each other (change it now / try the
+current version first), post a single ask with one `--option` per alternative. Never post two Yes/No
+cards for the two halves: the owner can tap Yes on both and you are left guessing. A second Yes/No
+ask on the same ticket within 60 seconds that reads as an either/or (starts with 还是 / 或者 / "or ",
+or the first one ends in an either/or) is rejected with an error telling you to post one card with
+options. Use plain Yes/No only for a single question with one possible action.
+
 What happens:
 
 - The card is posted by your own Slack bot:

package/config/skills/agent/core/ask-owner/execute.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# ask-owner — one structured owner decision (question + 2–3 options + default
+# ask-owner — one structured owner decision (question + 2–5 options + default
 # + deadline), posted as a Slack card by the asking agent's own bot.
 # See specs/2026-10-01-decision-cards.md.
 set -euo pipefail

package/config/skills/agent/core/project-tickets/SKILL.md

@@ -134,7 +134,7 @@ without a WorkItem). Team leads also have the `assign-ticket` skill.
 
 A **stopped** member is available: assigning starts it for the ticket (the
 answer's `wake` says `started`, or which gate refused it — then it picks the
-ticket up on its next start). Delegate by role; keep only lead-level work.
+ticket up on its next start). Role is a preference, not a limit: prefer an idle member; keep only lead-level work.
 
 ## Link work already in flight (orchestrator / team lead)
 
@@ -163,7 +163,7 @@ bash execute.sh ask-owner --project P --id APP-12 \
 bash execute.sh ask-owner --project P --id APP-12 --clear --note "resolved in the review call"
 ```
 
-ONE question with 2–3 options and a default (an option, or `wait`). The deadline defaults to
+ONE question with 2–5 options and a default (an option, or `wait`). The deadline defaults to
 tomorrow at 12:00. The ticket's assignee, else the lead, posts the question as a card in the
 ticket's Slack thread, using its own bot. The ticket gets `needs-owner` until the question is
 answered.

package/config/skills/agent/core/project-tickets/execute.sh

@@ -62,7 +62,7 @@ Usage:
                                                               flight (a live WorkItem) to this ticket
   bash execute.sh ask-owner --project P --id APP-12 --question "…" --option "A" --option "B — detail"
                           --default "B"|wait [--deadline ISO] [--sensitive email|publish|deploy|spend]
-                                                              Ask the owner ONE question with 2–3 options. The
+                                                              Ask the owner ONE question with 2–5 options. The
                                                               ticket's assignee (else its lead) posts it as a card
                                                               in the ticket's Slack thread; the answer comes back
                                                               to that agent as a [DECISION …] message

package/config/skills/agent/core/publish-app/SKILL.md

@@ -105,22 +105,29 @@ bash execute.sh --app 28au74d9cj --private                                  # pr
   holding anything private.
 - The output says `Requested: the owner approves it by opening the app.` It
   only **records a request**: the owner sees it as a banner in the app and
-  approves or declines it there, and the card you get with it tells them so.
-  To approve, the owner signs in again **with Google** in the app (a Crewly
-  login or token is not enough). **No agent can make an app public** — there
-  is no command for it, and Crewly Cloud only changes visibility from the
-  owner's own, freshly re-authenticated session. Do not tell the owner it is
-  public until they approved it.
+  approves or declines it in the Crewly Cloud portal (Apps → the app →
+  Sharing), which lists exactly which collections become readable/submittable.
+  **No agent can make an app public** — there is no command for it, and Crewly
+  Cloud only changes visibility from the owner's own portal sign-in. Do not
+  tell the owner it is public until they approved it.
+- **Visitors.** On a public link `await crewly.me()` returns `{ role: 'visitor' }`.
+  Visitors can only read `--public-read` collections and add to
+  `--public-submit` ones; every other write is refused. Build a read-only view
+  for them. **`window.crewly` and `crewly.db` are frozen** — never assign to
+  them (`crewly.db.set = noop` throws "Attempted to assign to readonly
+  property" in Safari). Route writes through your own wrapper, or replace the
+  global: `window.crewly = Object.freeze({ ...crewly, db: Object.freeze({ ...crewly.db, set: noop }) })`.
+  Test the public link as a visitor (a private window) before telling the owner.
 - **Names.** A public app's name (and the owner's display name) may not contain
   `crewly`, `sign in`, `sign-in`, `login`, `log in`, `password`, `verify`,
   `account`, `security` or `support` (any case). If you plan to ask for public,
   pick a name without them; `--public` with such a name is refused at once
   (`reason: "validation"`, the message names the word) — rename with `--name`.
-- **Every new version needs re-approval.** Publishing a new version of a
-  **public** app, or rolling one back, makes it **private again** with a
-  pending re-approval request. The output then has `"publicPaused": true` and
-  a message: tell the owner the app is private until they re-approve it in the
-  app. Batch your changes; do not publish a public app for small fixes.
+- **Public stays public.** Publishing a new version of a public app (or
+  rolling it back) keeps it public with the same exposure — links the owner
+  shared keep working. So test a new version before publishing it to a public
+  app. Widening what is public (more `--public-read` / `--public-submit`
+  collections) still needs a new request the owner approves.
 - `--private` is always allowed and takes effect at once. Use it if anything
   looks wrong (spam, abuse, a leak).
 

package/config/skills/agent/core/publish-app/execute.sh

@@ -8,7 +8,7 @@
 # applies) and sends their contents. specs/2026-10-04-crewly-apps-p2.md
 #
 # Publishing or rolling back a PUBLIC app takes it private until the owner
-# re-approves it (Cloud); the output then has "publicPaused": true.
+# stays public (since 2026-10-04 a new version no longer pauses it).
 #
 # P3 (specs/2026-10-04-crewly-apps-p3.md): the card carries a signed
 # one-tap link the backend mints and posts to the owner DM only — this

package/config/skills/team-leader/delegate-task/SKILL.md

@@ -49,6 +49,46 @@ Assigns a task to a worker within the Team Leader's subordinate scope. Validates
 | `--from` | `fromSession` | No | Delegating TL's session name (for monitoring) |
 | `--request-id` / `-R` | `requestId` | No | Ticket this work is for: the id (or `TKT-123`) from the `[TICKET:TKT-123 <id>]` line of the message you are acting on. Omit it and the task is still linked when your current turn has exactly one ticket |
 | `--ticket` | `ticket` | No | Project ticket this work is for (e.g. `APP-12`). Without it a ticket is created for you when the target works on a project — see Project tickets |
+| `--thread` | `thread` | No | Owner request from Slack: the key from the `[SLACK-THREAD:<key>]` of the owner's message. The member answers the owner in that thread itself — see Owner requests |
+| `--no-member-fits` | `noMemberFits` | No | You keep the work: record what is missing (access, tool, permission, everyone busy). Needs `--task`; nothing is delegated — see No member fits |
+| `--work-item` | `workItemId` | No | With `--no-member-fits`: the WorkItem you keep (gets a `[NO-MEMBER-FITS]` note) |
+
+## Who to delegate to
+
+Role is a preference, not a limit: every member runs the same runtime and can
+code, write and research. Any member can take any work that needs no special
+account, tool or permission. Prefer an idle (or stopped) member over doing it
+yourself. Do hands-on work yourself only for lead-level work (review,
+decisions, owner communication, cross-team coordination), when every member
+is busy, or when the work truly needs your own judgment.
+
+## Owner requests (`--thread`)
+
+When the owner asked in Slack, pass the thread key from the owner message's
+`[SLACK-THREAD:<key>]`:
+
+```bash
+bash execute.sh --to sage-session --task "Goal: … Outcome: … Eval: …" --thread C0THINK:1790000000.000100
+```
+
+The WorkItem carries the thread and the member is told to post its progress
+and result there itself (`reply --work-item <id>`), under its own name. You do
+not relay its answer; the room's reply gate never holds the member's post.
+Without `--thread` the thread of your last owner message is used. (A thread
+in your DM with the owner: the member's bot cannot post there, so it answers
+in its own DM with the owner, opened with `Re: <task>`.)
+
+## No member fits (`--no-member-fits`)
+
+Rare. When you keep work yourself, record why — what is missing, not a role
+mismatch — so the owner sees missing roles in the daily report:
+
+```bash
+bash execute.sh --no-member-fits "needs the owner's Stripe login" --task "Update billing settings" [--work-item <id>] [--ticket CE-7]
+```
+
+Nothing is delivered. With `--work-item` the WorkItem gets a
+`[NO-MEMBER-FITS] <reason>` note.
 
 ## Project tickets
 

package/config/skills/team-leader/delegate-task/execute.sh

@@ -18,6 +18,9 @@ TL_MEMBER_ID=""
 FROM_SESSION=""
 REQUEST_ID=""
 PROJECT_TICKET=""
+OWNER_THREAD=""
+NO_MEMBER_FITS=""
+KEPT_WORK_ITEM=""
 
 # Detect legacy JSON argument
 if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
@@ -38,10 +41,15 @@ while [[ $# -gt 0 ]]; do
     --from)        FROM_SESSION="$2";   shift 2 ;;
     --request-id|-R) REQUEST_ID="$2";   shift 2 ;;
     --ticket)      PROJECT_TICKET="$2"; shift 2 ;;
+    --thread)      OWNER_THREAD="$2";   shift 2 ;;
+    --no-member-fits) NO_MEMBER_FITS="$2"; shift 2 ;;
+    --work-item)   KEPT_WORK_ITEM="$2"; shift 2 ;;
     --json|-j)     INPUT_JSON="$2";     shift 2 ;;
     --help|-h)
       echo "Usage: execute.sh --to worker-session --task 'implement feature' --priority high --project /path [--team teamId] [--tl-member memberId] [--request-id <ticket id from the [TICKET:TKT-123 <id>] line>] [--ticket <project ticket id, e.g. APP-12>]"
       echo "Work for a teammate on a project always runs through a project ticket: --ticket uses that backlog/ready ticket, otherwise one is created for you."
+      echo "Owner request from Slack: add --thread <key> (from [SLACK-THREAD:<key>]) — the member answers the owner in that thread itself."
+      echo "Keeping work yourself because no member fits: execute.sh --no-member-fits '<what is missing: access / tool / permission / everyone busy>' --task '<the work>' [--work-item <id>] [--ticket <ID>]"
       exit 0
       ;;
     --)            shift; break ;;
@@ -79,6 +87,28 @@ if [ -n "$INPUT_JSON" ]; then
   [ -z "$FROM_SESSION" ] && FROM_SESSION=$(printf '%s' "$INPUT" | jq -r '.fromSession // empty')
   [ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
   [ -z "$PROJECT_TICKET" ] && PROJECT_TICKET=$(printf '%s' "$INPUT" | jq -r '.ticket // .projectTicketId // empty')
+  [ -z "$OWNER_THREAD" ] && OWNER_THREAD=$(printf '%s' "$INPUT" | jq -r '.thread // .ownerThread // empty')
+  [ -z "$NO_MEMBER_FITS" ] && NO_MEMBER_FITS=$(printf '%s' "$INPUT" | jq -r '.noMemberFits // empty')
+  [ -z "$KEPT_WORK_ITEM" ] && KEPT_WORK_ITEM=$(printf '%s' "$INPUT" | jq -r '.workItemId // empty')
+fi
+
+# "No member fits" (crewly#1083, specs/2026-10-04-tl-delegation.md §4): the
+# lead keeps this work. Record why, so the owner sees missing roles; nothing
+# is delivered to anyone.
+if [ -n "$NO_MEMBER_FITS" ]; then
+  require_param "task (--task)" "$TASK"
+  KEEP_BODY=$(jq -n --arg reason "$NO_MEMBER_FITS" --arg work "$(echo "$TASK" | head -c 300)" --arg workItemId "$KEPT_WORK_ITEM" --arg ticket "$PROJECT_TICKET" \
+    '{reason: $reason, work: $work} + (if $workItemId != "" then {workItemId: $workItemId} else {} end) + (if $ticket != "" then {ticket: $ticket} else {} end)')
+  KEEP_RESULT=$(api_call POST "/teams/lead-self-work" "$KEEP_BODY" 2>/dev/null || echo '{"success":false}')
+  if [ "$(echo "$KEEP_RESULT" | jq -r '.success // false' 2>/dev/null)" != "true" ]; then
+    error_exit "Could not record the kept work: $(echo "$KEEP_RESULT" | jq -r '.error // "unknown error"' 2>/dev/null)"
+  fi
+  if [ -n "$KEPT_WORK_ITEM" ]; then
+    NOTE_BODY=$(jq -n --arg author "${CREWLY_SESSION_NAME:-${FROM_SESSION:-team-leader}}" --arg note "[NO-MEMBER-FITS] ${NO_MEMBER_FITS}" '{author: $author, note: $note}')
+    api_call POST "/task-pool/items/${KEPT_WORK_ITEM}/notes" "$NOTE_BODY" >/dev/null 2>&1 || true
+  fi
+  echo "$KEEP_RESULT" | jq -c '{success: true, recorded: .data, info: "Recorded: you keep this work because no member fits. Nothing was delegated."}'
+  exit 0
 fi
 
 require_param "to (--to)" "$TO"
@@ -218,7 +248,8 @@ POOL_BODY=$(jq -n \
   --arg requestId "${REQUEST_ID:-}" \
   --arg projectTicketId "${PROJECT_TICKET:-}" \
   --arg delegatedBy "${CREWLY_SESSION_NAME:-${FROM_SESSION:-}}" \
-  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, briefMarkdown: $briefMarkdown, metadata: ({priority: $priority, directDelivery: true} + (if $projectPath != "" then {projectPath: $projectPath} else {} end) + (if $delegatedBy != "" then {delegatedBy: $delegatedBy} else {} end))} + (if $requestId != "" then {requestId: $requestId} else {} end) + (if $projectTicketId != "" then {projectTicketId: $projectTicketId} else {} end)')
+  --arg ownerThread "${OWNER_THREAD:-}" \
+  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, briefMarkdown: $briefMarkdown, metadata: ({priority: $priority, directDelivery: true} + (if $projectPath != "" then {projectPath: $projectPath} else {} end) + (if $delegatedBy != "" then {delegatedBy: $delegatedBy} else {} end) + (if $ownerThread != "" then {ownerThread: $ownerThread} else {} end))} + (if $requestId != "" then {requestId: $requestId} else {} end) + (if $projectTicketId != "" then {projectTicketId: $projectTicketId} else {} end)')
 # metadata.directDelivery: this script delivers the brief itself (below), so
 # the backend's workitem:queued push holds off and only fires if that
 # delivery never lands — the task reaches the worker once.
@@ -258,6 +289,13 @@ if [ -n "$TASK_ID" ]; then
   DELIVER_MESSAGE="WorkItem ${TASK_ID} — ${TASK_MESSAGE//<your WorkItem id>/$TASK_ID}"
 fi
 
+# Owner request from a Slack thread (crewly#1083): the backend names the
+# thread and tells the member to answer the owner there itself.
+OWNER_THREAD_NOTE=$(echo "$POOL_RESULT" | jq -r '.data.ownerThread.note // empty' 2>/dev/null || true)
+if [ -n "$OWNER_THREAD_NOTE" ]; then
+  DELIVER_MESSAGE="${DELIVER_MESSAGE}\n\n${OWNER_THREAD_NOTE}"
+fi
+
 if [ "$POOL_OK" != "true" ]; then
   # Unchanged from before the reorder: warn and still attempt delivery.
   # Aborting here instead would be a behavioural change beyond this WI's

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

@@ -6050,7 +6050,9 @@ export declare const DECISION_CONSTANTS: {
     readonly QUESTION_MIN_CHARS: 8;
     /** Allowed option count */
     readonly MIN_OPTIONS: 2;
-    readonly MAX_OPTIONS: 3;
+    readonly MAX_OPTIONS: 5;
+    /** Two yes/no asks on one ticket this close together that read as either/or are rejected (ms) */
+    readonly EITHER_OR_WINDOW_MS: number;
     /** Max characters of an option label (Slack button text max is 75) */
     readonly OPTION_LABEL_MAX_CHARS: 40;
     /** Max characters of an option's optional detail line */
@@ -6203,6 +6205,47 @@ export declare const WORK_ITEM_DESTINATION_CONSTANTS: {
     /** The one line every prompt carries about where to answer */
     readonly PROMPT_LINE: "Answer where you were asked; a new topic goes in a new thread.";
 };
+/**
+ * Team leads delegate instead of doing the work (crewly#1083,
+ * specs/2026-10-04-tl-delegation.md): owner-thread hand-over, the execution
+ * nudge, lead share of team tokens, and "no member fits" records.
+ */
+export declare const TL_DELEGATION_CONSTANTS: {
+    /** WorkItem.metadata / add-body field: the owner's Slack thread key a delegation answers */
+    readonly OWNER_THREAD_FIELD: "ownerThread";
+    /** A done item still lets its agent post in the owner's thread this long (ms) */
+    readonly DONE_THREAD_GRACE_MS: number;
+    /** Claude Code tools that count as hands-on file edits */
+    readonly EDIT_TOOLS: readonly string[];
+    /** Edits in the window that trigger a nudge */
+    readonly EDIT_THRESHOLD: 6;
+    /** Sliding window for counting edits (ms) */
+    readonly WINDOW_MS: number;
+    /** At most one nudge per lead per this long (ms) */
+    readonly NUDGE_COOLDOWN_MS: number;
+    /** A delegation this soon after a nudge counts as following it (ms) */
+    readonly FOLLOW_WINDOW_MS: number;
+    /** Members named in a nudge */
+    readonly NUDGE_MAX_MEMBERS: 3;
+    /** Tag that opens the nudge text */
+    readonly NUDGE_TAG: "[CREWLY-NUDGE]";
+    /** Note tag on a WorkItem the lead kept because no member fits */
+    readonly NO_MEMBER_FITS_TAG: "[NO-MEMBER-FITS]";
+    /** A lead share above this is flagged */
+    readonly FLAG_SHARE: 0.5;
+    /** Below this many team tokens in the period a share is not flagged (too little to judge) */
+    readonly MIN_TEAM_TOKENS: 1000000;
+    /** "This week" = the last N days */
+    readonly WEEK_DAYS: 7;
+    /** State file in CREWLY_HOME (nudge counts, kept-work records) */
+    readonly STATE_FILENAME: "tl-delegation.json";
+    /** Kept-work records retained */
+    readonly MAX_RECORDS: 500;
+    /** Max characters of a recorded reason / work line */
+    readonly MAX_TEXT_CHARS: 300;
+    /** Accepted tool_name from the hook */
+    readonly TOOL_NAME_PATTERN: RegExp;
+};
 /**
  * Harness-owned reply routing (specs/2026-10-02-harness-owned-routing.md).
  */
@@ -6239,7 +6282,8 @@ export declare const USAGE_BACKFILL_CONSTANTS: {
 /**
  * Daily token caps with a hard stop, team caps and temporary boosts
  * (specs/2026-10-02-spend-cap.md). The unit is TOKENS, not dollars (owner,
- * 2026-10-02): total tokens = input (fresh + cached) + output — see
+ * 2026-10-02): caps compare cost-weighted budget tokens (cache reads x0.1,
+ * crewly#1090); the raw total is input (fresh + cached) + output — see
  * `eventTokens` in token-usage.service. Caps are OFF until the owner sets
  * one. All owner-facing text is English.
  */