crewly 1.20.250 → 1.20.252

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

@@ -1,7 +1,7 @@
 ---
 name: App Comments
 description: The owner's comments on a Crewly App — each one points at an element they tapped in the app (data-crewly-id, CSS selector, text, outerHTML, position). List them, reply in the thread, resolve after you addressed one, reopen. Use it when an [APP CHANGES] message says the owner commented on your app or @mentioned you in a comment.
-version: 1.1.0
+version: 1.2.0
 category: productivity
 skillType: claude-skill
 assignableRoles:
@@ -64,6 +64,16 @@ Output (`--list`):
   "comment":"Make this green","at":"…","replies":[],"resolvedBy":null}]}
 ```
 
+## Apps owned by a team or a channel
+
+If the app's owner is a team or a Crewly channel (`app-data --owner`), each
+comment arrives as a thread in that room (and its Slack channel), not as an
+`[APP CHANGES]` message: "💬 Comment on Daily brief (#3) — Heading “Today”: …".
+The room's rules decide who answers. Reply **in that thread** (as for any room
+message): your reply is added to the comment in the app, so do not also run
+`--reply`. Use `--resolve <id>` when it is done; that shows in the thread too.
+The owner's replies in the thread (in Slack or in the app) reach the room once.
+
 ## Finding the element
 
 `on` is what the app's page reported for the tapped element:

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

@@ -1,7 +1,7 @@
 ---
 name: App Data
 description: Read and write the data of a Crewly App you published (the same collections the app's page sees through crewly.db) — list, get, set, update, add, delete. Use it to fill an app with content, act on what the owner entered, or answer an [APP CHANGES] message.
-version: 1.2.0
+version: 1.4.0
 category: productivity
 skillType: claude-skill
 assignableRoles:
@@ -44,6 +44,11 @@ bash execute.sh --app 28au74d9cj --set meta settings --data '{"title":"Weekly sh
 bash execute.sh --app 28au74d9cj --update items 1kx2-ab --data '{"done":true}' --if-rev 3
 bash execute.sh --app 28au74d9cj --add items --data '{"name":"eggs","done":false}'
 bash execute.sh --app 28au74d9cj --delete items 1kx2-ab
+bash execute.sh --app 28au74d9cj --request-access --reason "write the morning briefing"   # ask the owner, see "Collaborators"
+bash execute.sh --app 28au74d9cj --collaborators                                          # who the owner let in
+bash execute.sh --app 28au74d9cj --owner                                                  # who the app's comments go to
+bash execute.sh --app 28au74d9cj --set-owner 'channel:#daily-brief'                       # see "Owner"
+bash execute.sh --app 28au74d9cj --add-collaborator Kai                                   # owner agents only
 ```
 
 Output:
@@ -53,8 +58,9 @@ Output:
 {"success":true,"id":"settings","data":{"title":"Weekly shop"},"rev":1,"updatedAt":"…"}
 ```
 
-- You can use the data of apps you published or a teammate published
-  (`not_your_app` otherwise).
+- You can use the data of apps you published, that a teammate published, or
+  that the owner added you (or your team) to as a collaborator (`not_your_app`
+  otherwise).
 - `--data-file <path>` reads the JSON from a regular file inside your project
   directory (not a symlink, not under `~/.crewly`, at most 1 MB).
 - `--list` pages with `--after <next>` until `next` is null.
@@ -64,6 +70,62 @@ Output:
 - The app's page sees your writes at once (its subscriptions fire). Your
   writes never wake you; the owner's do (`[APP CHANGES]`).
 
+## Collaborators: working in an app another team published
+
+If the app is another team's, you get `not_your_app`. Do not publish a copy.
+Ask the owner:
+
+```bash
+bash execute.sh --app <appId> --request-access --reason "what you need to write"
+```
+
+- The owner gets one card, **Allow / Do not allow**. Only their tap grants
+  anything; you cannot add yourself, and nothing you send changes who is added
+  (it is your own team, or only you with `--scope agent`).
+- You are told when they answer. With **Allow** your team (and teammates who join
+  later) can use that app's **data and comments** with this skill, using the app
+  id. You get the app id from the owner or the publisher; collaborators do not
+  show up in `publish-app`'s list.
+- It is **data only**: you cannot republish, roll back, transfer or change who
+  can open the app (`publish-app --app <id>` is refused). To change the page
+  itself, ask the publisher.
+- The owner can take the access away at any time; your next call then returns
+  `not_your_app`.
+- `--list` shows who wrote each document: documents written by an agent carry
+  `by` (its session), e.g. `crewly-marketing-ella-…`.
+
+## Owner: who the app's comments go to
+
+Every app has an **owner**: one agent, a team, or a Crewly channel (a
+cross-team room, see `list-channels`). By default it is the agent that
+published it. The owner's comments in the app go to the owner:
+
+- agent → that agent, mirrored to its Slack DM with the owner (as before);
+- team → the team's room (its Slack team channel); the room's rules decide
+  who answers (an @mention in the comment → that agent; otherwise whoever is
+  awake reads it, and the lead when nobody is);
+- channel → that channel, so its members from every team see the owner's
+  comments and any of them can pick one up.
+
+```bash
+bash execute.sh --app <appId> --owner                                # {"owner":{"kind":"agent","name":"Ella","default":true}}
+bash execute.sh --app <appId> --set-owner 'channel:#daily-brief'     # or 'team:Dev', 'agent:Kai', default
+bash execute.sh --app <appId> --add-collaborator Kai                 # let another agent of this machine use the data
+```
+
+- Only the app's **owner agents** may change the owner or add a collaborator:
+  the owning agent, or a member of the owning team / channel (by default the
+  publisher). Anyone else gets `forbidden`; ask the owner, or use
+  `--request-access` for yourself.
+- Members of the owning team or channel can use the app's data and comments
+  without being added. A collaborator gets data and comments only, never
+  publishing (that stays with the publisher's team).
+- In a room, answer in the comment's thread: your reply there is added to the
+  comment in the app (do not also use `app-comments --reply`). Resolve with
+  `app-comments --resolve <id>` when it is done.
+- The channel or team must exist on this machine (a channel made a moment ago
+  is fine).
+
 ## What you read is a sanitised display copy
 
 Every string you read here — values **and** object keys, at any depth — is

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

@@ -19,6 +19,11 @@ Usage:
   bash execute.sh --app <appId> --update <collection> <docId> --data '{"done":true}' [--if-rev 4]
   bash execute.sh --app <appId> --add <collection> --data '{"name":"milk"}'
   bash execute.sh --app <appId> --delete <collection> <docId>
+  bash execute.sh --app <appId> --request-access [--scope team|agent] [--reason "why"]
+  bash execute.sh --app <appId> --collaborators
+  bash execute.sh --app <appId> --owner
+  bash execute.sh --app <appId> --set-owner 'channel:#daily-brief'   # or 'team:<name>', 'agent:<name>', default
+  bash execute.sh --app <appId> --add-collaborator <agent name or session>
 
 Options:
   --app        App id (from publish-app)
@@ -26,6 +31,13 @@ Options:
   --if-rev     Only update when the doc is still at this rev (409 conflict otherwise)
   --limit      Page size for --list (1-500, default 100)
   --after      Continue a --list after this doc id (the previous page's "next")
+  --request-access  Ask the owner to let your team (default) or only you work in an app another team published; a card goes to the owner, nothing is granted until they tap Allow
+  --collaborators   Who the owner let work in the app
+  --scope      team (your team, default) or agent (only you), with --request-access
+  --reason     One line for the owner, with --request-access
+  --owner      Show who owns the app's comments (an agent, a team or a channel)
+  --set-owner  Change it: channel:#<name>, team:<name>, agent:<name> or default (the publishing agent). Only the app's owner agents (and the owner) may
+  --add-collaborator  An owner agent lets another agent of this machine work in the app's data
   --help | -h  Show this help
 EOF_USAGE
 }
@@ -69,7 +81,7 @@ process.stdout.write(fs.readFileSync(r, 'utf8'));
 NODE
 }
 
-APP=""; OP=""; COLL=""; DOC=""; DATA=""; IF_REV=""; LIMIT=""; AFTER=""
+APP=""; OP=""; COLL=""; DOC=""; DATA=""; IF_REV=""; LIMIT=""; AFTER=""; SCOPE=""; REASON=""; SET_OWNER=""; WHO=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --app)    [ $# -ge 2 ] || error_exit "--app requires a value"; APP="$2"; shift 2 ;;
@@ -84,18 +96,54 @@ while [[ $# -gt 0 ]]; do
     --if-rev)    [ $# -ge 2 ] || error_exit "--if-rev requires a value";    IF_REV="$2"; shift 2 ;;
     --limit)     [ $# -ge 2 ] || error_exit "--limit requires a value";     LIMIT="$2"; shift 2 ;;
     --after)     [ $# -ge 2 ] || error_exit "--after requires a value";     AFTER="$2"; shift 2 ;;
+    --request-access) OP="request-access"; shift ;;
+    --collaborators)  OP="collaborators"; shift ;;
+    --owner)     OP="owner"; shift ;;
+    --set-owner) [ $# -ge 2 ] || error_exit "--set-owner requires an owner (channel:#name, team:<name>, agent:<name> or default)"; OP="owner"; SET_OWNER="$2"; shift 2 ;;
+    --add-collaborator) [ $# -ge 2 ] || error_exit "--add-collaborator requires an agent name or session"; OP="add-collaborator"; WHO="$2"; shift 2 ;;
+    --scope)     [ $# -ge 2 ] || error_exit "--scope requires a value";     SCOPE="$2"; shift 2 ;;
+    --reason)    [ $# -ge 2 ] || error_exit "--reason requires a value";    REASON="$2"; shift 2 ;;
     --help|-h)   print_usage; exit 0 ;;
     *) error_exit "Unknown option: $1" ;;
   esac
 done
 
 [ -n "$APP" ] || error_exit "--app is required"
-[ -n "$OP" ] || error_exit "one of --list / --get / --set / --update / --add / --delete is required"
+[ -n "$OP" ] || error_exit "one of --list / --get / --set / --update / --add / --delete / --request-access / --collaborators / --owner / --add-collaborator is required"
 [[ "$APP" =~ ^[a-z0-9]{10}$ ]] || error_exit "--app must be a 10-character app id"
 case "$COLL" in .|..) error_exit "collection cannot be . or .." ;; esac
 case "$DOC" in .|..) error_exit "doc id cannot be . or .." ;; esac
 BASE="/apps/${APP}/data/$(uri "$COLL")"
 
+case "$OP" in
+  request-access)
+    case "$SCOPE" in ""|team|agent) ;; *) error_exit "--scope is team or agent" ;; esac
+    BODY=$(jq -cn --arg s "$SCOPE" --arg r "$REASON" '{} + (if $s != "" then {scope: $s} else {} end) + (if $r != "" then {reason: $r} else {} end)')
+    RESPONSE=$(call POST "/apps/${APP}/collaborators/request" "$BODY") || { printf '%s\n' "$RESPONSE"; exit 1; }
+    printf '%s' "$RESPONSE" | jq -c '{success: true, requested: .data.requested, for: .data.for, note: "The owner got a card. You are told here when they answer; until then you still cannot use this app."}'
+    exit 0
+    ;;
+  collaborators)
+    RESPONSE=$(call GET "/apps/${APP}/collaborators") || { printf '%s\n' "$RESPONSE"; exit 1; }
+    printf '%s' "$RESPONSE" | jq -c '{success: true, collaborators: [.data.collaborators[]? | {id, kind, name, who}]}'
+    exit 0
+    ;;
+  owner)
+    if [ -n "$SET_OWNER" ]; then
+      RESPONSE=$(call PUT "/apps/${APP}/owner" "$(jq -cn --arg o "$SET_OWNER" '{owner: $o}')") || { printf '%s\n' "$RESPONSE"; exit 1; }
+    else
+      RESPONSE=$(call GET "/apps/${APP}/owner") || { printf '%s\n' "$RESPONSE"; exit 1; }
+    fi
+    printf '%s' "$RESPONSE" | jq -c '{success: true, owner: (.data.owner | if . == null then null else {kind, name, default: (.explicit | not)} + (if .members then {members: .members} else {} end) end)}'
+    exit 0
+    ;;
+  add-collaborator)
+    RESPONSE=$(call POST "/apps/${APP}/collaborators/agents" "$(jq -cn --arg a "$WHO" '{agent: $a}')") || { printf '%s\n' "$RESPONSE"; exit 1; }
+    printf '%s' "$RESPONSE" | jq -c '{success: true, collaborators: [.data.collaborators[]? | {id, kind, name, who}]}'
+    exit 0
+    ;;
+esac
+
 need_data() {
   [ -n "$DATA" ] || error_exit "--data is required for --$OP"
   printf '%s' "$DATA" | jq -e 'type == "object"' >/dev/null 2>&1 || error_exit "--data must be a JSON object"
@@ -107,7 +155,7 @@ case "$OP" in
     [ -n "$LIMIT" ] && Q="limit=$(uri "$LIMIT")"
     [ -n "$AFTER" ] && Q="${Q:+$Q&}after=$(uri "$AFTER")"
     RESPONSE=$(call GET "${BASE}${Q:+?$Q}") || { printf '%s\n' "$RESPONSE"; exit 1; }
-    printf '%s' "$RESPONSE" | jq -c '{success: true, docs: [.data.docs[]? | {id, data, rev, updatedAt, updatedBy: (.updatedBy.kind // null)}], next: .data.next}'
+    printf '%s' "$RESPONSE" | jq -c '{success: true, docs: [.data.docs[]? | {id, data, rev, updatedAt, updatedBy: (.updatedBy.kind // null)} + (if .updatedBy.kind == "agent" then {by: .updatedBy.id} else {} end)], next: .data.next}'
     ;;
   get)
     RESPONSE=$(call GET "${BASE}/$(uri "$DOC")") || { printf '%s\n' "$RESPONSE"; exit 1; }

package/config/skills/agent/core/app-data/execute.test.sh

@@ -26,6 +26,18 @@ class H(BaseHTTPRequestHandler):
             self.wfile.write(json.dumps(obj).encode())
         if self.path.endswith('/missing'):
             return send(404, {'success': False, 'error': 'not_found', 'message': 'Document not found.', 'hint': 'No such app, document or version for this account.'})
+        if self.path.endswith('/collaborators') and method == 'GET':
+            return send(200, {'success': True, 'data': {'collaborators': [{'id': 'e1', 'kind': 'team', 'who': 'Marketing', 'name': 'Marketing', 'instanceId': 'i'}]}})
+        if self.path.endswith('/owner'):
+            if method == 'PUT':
+                return send(200, {'success': True, 'data': {'appId': 'x', 'owner': {'kind': 'channel', 'explicit': True, 'channelId': 'h1', 'name': '#daily-brief', 'instanceId': 'i', 'members': ['a', 'b']}, 'previous': None}})
+            return send(200, {'success': True, 'data': {'appId': 'x', 'owner': {'kind': 'agent', 'explicit': False, 'session': 'dev-ella', 'name': 'Ella', 'instanceId': 'i'}}})
+        if self.path.endswith('/collaborators/agents'):
+            return send(200, {'success': True, 'data': {'collaborators': [{'id': 'e2', 'kind': 'agent', 'who': 'crewly-dev-kai-1', 'name': 'Kai', 'instanceId': 'i'}]}})
+        if self.path.endswith('/collaborators/request'):
+            return send(200, {'success': True, 'data': {'requested': True, 'decisionId': 'D-1', 'for': 'the Marketing team'}})
+        if self.path.endswith('/byagent'):
+            return send(200, {'success': True, 'data': {'docs': [{'id': 'a', 'data': {}, 'rev': 1, 'updatedAt': 't', 'updatedBy': {'kind': 'agent', 'id': 'crewly-marketing-ella-1'}}], 'next': None}})
         if (data or {}).get('ifRev') == 1:
             return send(409, {'success': False, 'error': 'conflict', 'message': 'rev mismatch'})
         if method == 'GET' and '?' in self.path or self.path.endswith('/items'):
@@ -104,5 +116,35 @@ check "data-file in Crewly home refused" "$(printf '%s' "$OUT" | grep -c "inside
 OUT=$(run_err --app $A --get items .. || true)
 check "doc id .. refused" "$(printf '%s' "$OUT" | grep -c 'cannot be')" "1"
 
+# A write by an agent shows who (the session); an owner write does not carry an id.
+OUT=$(run --app $A --list byagent)
+check "list: agent write shows its session" "$(printf '%s' "$OUT" | jq -c '.docs[0] | {updatedBy, by}')" '{"updatedBy":"agent","by":"crewly-marketing-ella-1"}'
+
+# Asking for access: POST .../collaborators/request with the scope and reason only.
+OUT=$(run --app $A --request-access --scope agent --reason "write the briefing")
+check "request-access: path" "$(jq -r '.method + " " + .path' "$STUB_LOG")" "POST /api/apps/$A/collaborators/request"
+check "request-access: body" "$(jq -c .body "$STUB_LOG")" '{"scope":"agent","reason":"write the briefing"}'
+check "request-access: output says requested" "$(printf '%s' "$OUT" | jq -c '{success, requested, for}')" '{"success":true,"requested":true,"for":"the Marketing team"}'
+OUT=$(run_err --app $A --request-access --scope everyone || true)
+check "request-access: bad scope refused" "$(printf '%s' "$OUT" | grep -c 'team or agent')" "1"
+OUT=$(run --app $A --collaborators)
+check "collaborators: output" "$OUT" '{"success":true,"collaborators":[{"id":"e1","kind":"team","name":"Marketing","who":"Marketing"}]}'
+
+# App owner (crewly-services apps/SPEC.md §15).
+OUT=$(run --app $A --owner)
+check "owner: shows the default owner" "$OUT" '{"success":true,"owner":{"kind":"agent","name":"Ella","default":true}}'
+check "owner: GET path" "$(jq -r '.method + " " + .path' "$STUB_LOG")" "GET /api/apps/$A/owner"
+OUT=$(run --app $A --set-owner 'channel:#daily-brief')
+check "set-owner: request" "$(jq -c '{method, path, body}' "$STUB_LOG")" "{\"method\":\"PUT\",\"path\":\"/api/apps/$A/owner\",\"body\":{\"owner\":\"channel:#daily-brief\"}}"
+check "set-owner: output" "$OUT" '{"success":true,"owner":{"kind":"channel","name":"#daily-brief","default":false,"members":["a","b"]}}'
+OUT=$(run --app $A --add-collaborator Kai)
+check "add-collaborator: request" "$(jq -c '{method, path, body}' "$STUB_LOG")" "{\"method\":\"POST\",\"path\":\"/api/apps/$A/collaborators/agents\",\"body\":{\"agent\":\"Kai\"}}"
+check "add-collaborator: output" "$(printf '%s' "$OUT" | jq -c '.collaborators[0].name')" '"Kai"'
+OUT=$(run_err --app $A --set-owner || true)
+check "set-owner needs a value" "$(printf '%s' "$OUT" | grep -c 'requires an owner')" "1"
+# --set still means a data write.
+run --app $A --set items milk --data '{"done":true}' >/dev/null
+check "--set is still a data write" "$(jq -r '.method + " " + .path' "$STUB_LOG")" "PUT /api/apps/$A/data/items/milk"
+
 echo "app-data: $PASS passed, $FAIL failed"
 [ "$FAIL" -eq 0 ]

package/config/skills/agent/core/complete-task/SKILL.md

@@ -37,7 +37,7 @@ execution:
 
 # Complete Task
 
-Mark a task as complete with a summary of the work done. If the task has an output schema, provide structured output that will be validated against the schema. Optionally skip quality gates if they have already been verified separately.
+Mark a task as complete with a summary of the work done. If the task has an output schema, provide structured output that will be validated against the schema. Unknown fields are refused, never silently dropped.
 
 ## Parameters
 
@@ -51,6 +51,10 @@ Mark a task as complete with a summary of the work done. If the task has an outp
 | `output` | No | Structured output object (required if task has an output schema) |
 | ~~`skipGates`~~ | **Rejected** | **Not supported.** This endpoint runs no quality gates, so there is nothing to skip. Passing it is a hard error. Use the `check-quality-gates` skill for gates. |
 
+**Any other field is an error.** The skill accepts only the fields in this table plus `verdict`/`feedback` (reviews) and `taskId`/`artifacts`/`testResults`/`structured` (verification requests). An unknown field (for example `projectPath`, `skipGates`, `force`) stops the call before anything is sent, and the error names the field. Put extra results inside `output`.
+
+On success the skill prints **one JSON line** that always names the `workItemId`, plus the server's reply (`success`, `message`, any `warning`).
+
 ### Which WorkItem gets completed
 
 Resolution order:

package/config/skills/agent/core/complete-task/execute.sh

@@ -19,27 +19,31 @@ INPUT=$(read_json_input "${1:-}")
 # /api/task-pool/complete by hand. Same silent-friction class as the
 # create-task `{workItem: ...}` wrapper: the skill rejected a request that
 # was, by its own contract, correct.
+if [ "$(printf '%s' "$INPUT" | jq -r 'type' 2>/dev/null || echo invalid)" != "object" ]; then
+  error_exit "complete-task input must be a JSON object, e.g. {\"workItemId\":\"wi-abc123\",\"sessionName\":\"dev-1\",\"summary\":\"...\"}"
+fi
 WORK_ITEM_ID=$(printf '%s' "$INPUT" | jq -r '.workItemId // empty')
 ABSOLUTE_TASK_PATH=$(printf '%s' "$INPUT" | jq -r '.absoluteTaskPath // empty')
 SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
 SUMMARY=$(printf '%s' "$INPUT" | jq -r '.summary // empty')
-# `skipGates` is REJECTED, not ignored.
-#
-# It was previously parsed here and forwarded in the request body. Nothing ever
-# read it: `completeItem` destructures only `{agentId, tokenUsage, result}`
-# (task-pool.controller.ts), and `POST /task-pool/complete/:id` runs no quality
-# gates at all — gates live behind `POST /quality-gates/check`, reached via the
-# `check-quality-gates` skill. So the field promised to skip something this
-# endpoint never runs.
+# Unknown top-level fields are REJECTED, not ignored (CREW-267).
 #
-# Accepting-and-ignoring is the worst of the three dispositions: the caller
-# believes gates were skipped, the belief is unfalsifiable, and nothing ever
-# fails. Honouring it is incoherent (there is nothing here to skip). So it
-# fails loudly instead. Safe to hard-error: no caller in the repo passes it.
-SKIP_GATES=$(printf '%s' "$INPUT" | jq -r '.skipGates // empty')
-if [ -n "$SKIP_GATES" ]; then
+# `skipGates` was once parsed and forwarded, and nothing ever read it:
+# `POST /task-pool/complete/:id` runs no quality gates (they live behind the
+# `check-quality-gates` skill). On 2026-10-06 seven completions passed it,
+# printed a bare `{}`, and looked closed when they were not. Accepting and
+# ignoring a field is the worst disposition: the caller believes it did
+# something, and nothing ever fails. So every field this skill does not use
+# fails loudly, with its name, before any request is sent.
+ALLOWED_FIELDS='["workItemId","absoluteTaskPath","sessionName","summary","output","evidence","verdict","feedback","taskId","artifacts","testResults","structured"]'
+SKIP_GATES=$(printf '%s' "$INPUT" | jq -r 'has("skipGates")')
+if [ "$SKIP_GATES" = "true" ]; then
   error_exit "skipGates is not supported by complete-task and never was — it was accepted and silently discarded. POST /task-pool/complete runs no quality gates, so there is nothing here to skip. Quality gates live behind the 'check-quality-gates' skill (POST /quality-gates/check); run or skip them there. Remove skipGates from this call."
 fi
+UNKNOWN_FIELDS=$(printf '%s' "$INPUT" | jq -r --argjson allowed "$ALLOWED_FIELDS" '[keys[] | select(. as $k | $allowed | index($k) | not)] | join(", ")')
+if [ -n "$UNKNOWN_FIELDS" ]; then
+  error_exit "complete-task does not accept: ${UNKNOWN_FIELDS}. Nothing was completed. Remove the field(s) and call again. Accepted fields: $(printf '%s' "$ALLOWED_FIELDS" | jq -r 'join(", ")'). Put structured results inside \"output\" and proof inside \"evidence\"."
+fi
 OUTPUT_JSON=$(printf '%s' "$INPUT" | jq -c '.output // empty')
 # Evidence contract (#873): "done" needs evidence. Each entry is one of
 #   {"type":"artifact","path":"<existing file, relative to the project/worktree, or https URL>"}
@@ -168,7 +172,18 @@ BODY=$(jq -n \
   }')
 
 COMPLETE_RESPONSE=$(api_call POST "/task-pool/complete/${WORK_ITEM_ID}" "$BODY")
-printf '%s\n' "$COMPLETE_RESPONSE"
+# Always one result line naming the WorkItem (CREW-267): a bare `{}` read as
+# "closed" when nothing said so. A non-empty object is passed through with
+# the id added; an empty or non-JSON body gets an explicit line instead.
+RESULT_LINE=$(printf '%s' "$COMPLETE_RESPONSE" | jq -c --arg id "$WORK_ITEM_ID" '
+  if type == "object" and length > 0 then {workItemId: $id} + .
+  else {success: true, workItemId: $id, message: ("WorkItem " + $id + " completion was accepted, but the server sent no details. Check it with GET /api/task-pool/items/" + $id + ".")}
+  end' 2>/dev/null || true)
+if [ -z "$RESULT_LINE" ]; then
+  RESULT_LINE=$(jq -nc --arg id "$WORK_ITEM_ID" --arg raw "$COMPLETE_RESPONSE" \
+    '{success: true, workItemId: $id, message: ("WorkItem " + $id + " completion was accepted; the server reply was not JSON."), raw: $raw}')
+fi
+printf '%s\n' "$RESULT_LINE"
 # Warn-mode rollout (#873): the server accepts a completion without evidence
 # for one release but says so. Repeat it on stderr so it is not missed.
 EVIDENCE_WARNING=$(printf '%s' "$COMPLETE_RESPONSE" | jq -r '.warning // empty' 2>/dev/null || true)

package/config/skills/agent/core/complete-task/execute.test.sh

@@ -233,7 +233,7 @@ echo "--- Finished-task summary stays out of long-term memory (#833) ---"
 
 # The summary lives on the WorkItem and in task-history.json. Saving it as a
 # project decision crowded real decisions out of recall.
-run_skill '{"workItemId":"wi-833","sessionName":"dev-1","summary":"Shipped the importer","projectPath":"/proj"}'
+run_skill '{"workItemId":"wi-833","sessionName":"dev-1","summary":"Shipped the importer"}'
 assert_contains "completion still reaches the task pool" \
   "POST http://stub.invalid/api/task-pool/complete/wi-833" "$REQUESTS"
 assert_not_contains "no /memory/remember call on completion" "/memory/remember" "$REQUESTS"
@@ -267,6 +267,50 @@ STUB_COMPLETE_RESPONSE='{"success":true,"message":"WorkItem wi-plain completed",
   run_skill '{"workItemId":"wi-plain","sessionName":"dev-1","summary":"Report written"}'
 assert_contains "server warning is printed" '"warning": "Completed WITHOUT evidence' "$OUT"
 
+echo ""
+echo "--- Unknown fields fail loudly, before any request (CREW-267) ---"
+
+run_skill '{"workItemId":"wi-u","sessionName":"dev-1","summary":"done","projectPath":"/proj"}'
+assert_contains "an unknown field is refused" '"error"' "$OUT"
+assert_contains "the refusal names the field" "projectPath" "$OUT"
+assert_contains "the refusal says nothing was completed" "Nothing was completed" "$OUT"
+assert_not_contains "no request is sent for an unknown field" "/task-pool/complete" "$REQUESTS"
+
+run_skill '{"workItemId":"wi-u","sessionName":"dev-1","summary":"done","fallback":true,"force":1}'
+assert_contains "every unknown field is named (1)" "fallback" "$OUT"
+assert_contains "every unknown field is named (2)" "force" "$OUT"
+assert_not_contains "no request is sent for several unknown fields" "/task-pool/complete" "$REQUESTS"
+
+run_skill '{"workItemId":"wi-u","sessionName":"dev-1","summary":"done","skipGates":false}'
+assert_contains "skipGates is refused even when false" "skipGates is not supported" "$OUT"
+assert_not_contains "no request is sent for skipGates" "/task-pool/complete" "$REQUESTS"
+
+run_skill '["not","an","object"]'
+assert_contains "a non-object input is refused" "must be a JSON object" "$OUT"
+
+run_skill '{"workItemId":"wi-ok","sessionName":"dev-1","summary":"done","output":{"x":1},"evidence":[],"verdict":"verified","taskId":"t","artifacts":[],"testResults":"ok","structured":false,"absoluteTaskPath":"/x"}'
+assert_not_contains "every documented field is still accepted" "does not accept" "$OUT"
+assert_contains "a call with every documented field completes" \
+  "POST http://stub.invalid/api/task-pool/complete/wi-ok" "$REQUESTS"
+
+echo ""
+echo "--- Success always prints one result line naming the WorkItem (CREW-267) ---"
+
+STUB_COMPLETE_RESPONSE='{}' run_skill '{"workItemId":"wi-empty","sessionName":"dev-1","summary":"done"}'
+BARE_LINES="$(printf '%s\n' "$OUT" | grep -cx '{}' || true)"
+assert_contains "an empty server reply is not echoed as a bare {}" "0" "$BARE_LINES"
+LAST_LINE="$(printf '%s' "$OUT" | tail -1)"
+assert_contains "the result line names the WorkItem" '"workItemId":"wi-empty"' "$LAST_LINE"
+assert_contains "the result line says the server sent no details" "no details" "$LAST_LINE"
+
+STUB_COMPLETE_RESPONSE='{"success":true,"message":"WorkItem wi-full completed"}' \
+  run_skill '{"workItemId":"wi-full","sessionName":"dev-1","summary":"done"}'
+LAST_LINE="$(printf '%s' "$OUT" | tail -1)"
+assert_contains "the server reply is kept" '"message":"WorkItem wi-full completed"' "$LAST_LINE"
+assert_contains "the server reply gains the WorkItem id" '"workItemId":"wi-full"' "$LAST_LINE"
+LINE_COUNT="$(printf '%s\n' "$OUT" | grep -c '"workItemId":"wi-full"' || true)"
+assert_contains "the result is a single line" "1" "$LINE_COUNT"
+
 rm -rf "$STUB_DIR"
 
 echo ""

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

@@ -1,7 +1,7 @@
 ---
 name: Publish App
 description: Publish a small web app (HTML/JS) you wrote to https://apps.crewlyai.com/<appId> so the owner can open it on their phone. Creates the app the first time, uploads a new version each time after (same app for the same directory), supports rollback, and can post an "Open app" card to the owner (a one-tap signed link, in your DM with them). Can ask the owner to make an app public (only the owner can approve it). The owner's edits, comments on elements, and anonymous visitors' submissions on a public app, come back to you as an [APP CHANGES] message.
-version: 1.4.0
+version: 1.5.0
 category: productivity
 skillType: claude-skill
 assignableRoles:
@@ -48,6 +48,8 @@ bash execute.sh --html ./timer.html --name "Timer"
 bash execute.sh --app 28au74d9cj --rollback 2                  # back to version 2
 bash execute.sh --app 28au74d9cj --versions
 bash execute.sh --app 28au74d9cj --transfer-to edu-game-milo-13e8d3ca   # hand the app to another agent / team
+bash execute.sh --dir ./daily-brief --owner 'channel:#daily-brief'        # publish, and send the owner's comments to a channel
+bash execute.sh --app 28au74d9cj --owner 'team:Dev'                       # change only who gets the comments
 bash execute.sh --list                                         # apps published from this machine
 bash execute.sh --app 28au74d9cj --share                       # send the owner a fresh one-tap link (no publish)
 bash execute.sh --app 28au74d9cj --links                       # its open-links; --revoke-link <id> / --revoke-links
@@ -132,6 +134,8 @@ bash execute.sh --app 28au74d9cj --private                                  # pr
   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.
+- Collaborators: an app another team published is not yours to republish. `--app <id>` from a team that did not publish it is refused (`not_your_app`), including when the owner added your team as a collaborator: collaborators get the app's **data and comments** only (use `app-data`; ask with `app-data --app <id> --request-access`). To change the page itself, ask the publisher or the owner to transfer the app (`--transfer-to`).
+- Owner: `--owner channel:#<name> | team:<name> | agent:<name> | default` sets who the owner's **comments** go to (a channel's members from every team see them; see `app-data` → Owner). It does not change who publishes. Only the app's owner agents may change it (by default the publisher); with a publish the owner is set right after it, and an `ownerError` in the output means only that part failed.
 - Transfer: `--app <appId> --transfer-to <session>` hands the app to another agent, e.g. when the owner moves the work to a new team. Only the app's publisher, the lead of its team, the orchestrator or the owner may do it, and the target must be a member of an active team on this machine. Afterwards the new publisher publishes with `--app <appId> --dir <its directory>`, comments and changes go to it, and the old team can no longer publish, roll back or use the app's data. Both agents get a short note.
 - Thumbnails: the owner's portal list shows a small screenshot of each app. Publishing (and rollback) takes it automatically in the background when this machine has Chrome or Chromium; `bash execute.sh --app <appId> --refresh-thumbnail` re-takes it now (answers `captured:false` with a reason such as `no_browser` when it cannot).
 - `--private` is always allowed and takes effect at once. Use it if anything

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

@@ -29,6 +29,7 @@ Usage:
   bash execute.sh --app <appId> --rollback <version>    # make an earlier version current
   bash execute.sh --app <appId> --versions              # list versions
   bash execute.sh --app <appId> --transfer-to <session> # hand the app to another agent / team
+  bash execute.sh --app <appId> --owner 'channel:#daily-brief'   # who gets the owner's comments (also with a publish)
   bash execute.sh --list                                # apps published from this machine
   bash execute.sh --app <appId> --share [--ttl-days 7]  # fresh one-tap link card to the owner (no publish)
   bash execute.sh --app <appId> --links                 # open-links of the app (no secrets)
@@ -63,6 +64,8 @@ Options:
   --rollback   Version number to make current (needs --app)
   --versions   List versions (needs --app)
   --transfer-to  Hand the app to another agent (its session name; it must be on a team on this machine).
+  --owner      Who owns the app's comments: channel:#<name>, team:<name>, agent:<name> or default (the publishing agent).
+               With a publish it is set after the publish; alone it needs --app. Only the app's owner agents may change it.
                  Allowed for the app's publisher, the lead of its team, the orchestrator or the owner.
                  The new publisher publishes with --app <appId> --dir <its directory>; the old team loses access.
   --list       List apps published from this machine
@@ -84,7 +87,7 @@ call() {
 }
 
 DIR=""; FILE=""; NAME=""; APP=""; ENTRY=""; NOTE=""; NOTIFY=false; ROLLBACK=""; TRANSFER_TO=""; VERSIONS=false; LIST=false
-SHARE=false; TTL_DAYS=""; LINKS=false; REVOKE_LINK=""; REVOKE_LINKS=false
+SHARE=false; TTL_DAYS=""; LINKS=false; REVOKE_LINK=""; REVOKE_LINKS=false; OWNER_SPEC=""
 PUBLIC=false; PUBLIC_READ=""; PUBLIC_SUBMIT=""; PUBLIC_NOTE=""; CANCEL_PUBLIC=false; PRIVATE=false; REFRESH_THUMB=false
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -110,6 +113,7 @@ while [[ $# -gt 0 ]]; do
     --refresh-thumbnail) REFRESH_THUMB=true; shift ;;
     --versions) VERSIONS=true; shift ;;
     --transfer-to) [ $# -ge 2 ] || error_exit "--transfer-to requires a session name"; TRANSFER_TO="$2"; shift 2 ;;
+    --owner)    [ $# -ge 2 ] || error_exit "--owner requires channel:#<name>, team:<name>, agent:<name> or default"; OWNER_SPEC="$2"; shift 2 ;;
     --list)     LIST=true; shift ;;
     --help|-h)  print_usage; exit 0 ;;
     *) error_exit "Unknown option: $1" ;;
@@ -201,6 +205,15 @@ if [ -z "$DIR" ] && [ -z "$FILE" ]; then
   fi
 fi
 
+# The app's owner (crewly-services apps/SPEC.md §15): who its comments go to.
+OWNER_JQ='(.data.owner | if . == null then null else {kind, name, default: (.explicit | not)} end)'
+if [ -n "$OWNER_SPEC" ] && [ -z "$DIR" ] && [ -z "$FILE" ]; then
+  [ -n "$APP" ] || error_exit "--app is required with --owner (or publish with --dir / --html)"
+  RESPONSE=$(call PUT "/apps/${APP}/owner" "$(jq -cn --arg o "$OWNER_SPEC" '{owner: $o}')") || { printf '%s\n' "$RESPONSE"; exit 1; }
+  printf '%s' "$RESPONSE" | jq -c '{success: true, appId: .data.appId, owner: '"$OWNER_JQ"'}'
+  exit 0
+fi
+
 if [ -n "$TRANSFER_TO" ]; then
   [ -n "$APP" ] || error_exit "--app is required with --transfer-to"
   BODY=$(jq -cn --arg s "$TRANSFER_TO" '{toSession: $s}')
@@ -311,9 +324,19 @@ OUT=$(curl -s -w '\n%{http_code}' -X POST -H "Content-Type: application/json" ${
 CODE=$(printf '%s\n' "$OUT" | tail -n 1)
 RESP=$(printf '%s\n' "$OUT" | sed '$d')
 if [ "$CODE" -ge 200 ] 2>/dev/null && [ "$CODE" -lt 300 ] 2>/dev/null; then
-  printf '%s' "$RESP" | jq -c --arg msg "$PUBLIC_MSG" '.data | {success: true, appId, name, url: ("https://apps.crewlyai.com/" + .appId), version, created, notified} + '"$CARD_JQ"'
+  OWNER_OUT='{}'
+  if [ -n "$OWNER_SPEC" ]; then
+    NEW_APP=$(printf '%s' "$RESP" | jq -r '.data.appId // empty')
+    if OWNER_RESP=$(call PUT "/apps/${NEW_APP}/owner" "$(jq -cn --arg o "$OWNER_SPEC" '{owner: $o}')"); then
+      OWNER_OUT=$(printf '%s' "$OWNER_RESP" | jq -c '{owner: '"$OWNER_JQ"'}')
+    else
+      # The publish went through; only the owner change failed.
+      OWNER_OUT=$(printf '%s' "$OWNER_RESP" | jq -c '{ownerError: (.message // .reason // "failed")}' 2>/dev/null || echo '{"ownerError":"failed"}')
+    fi
+  fi
+  printf '%s' "$RESP" | jq -c --arg msg "$PUBLIC_MSG" --argjson own "$OWNER_OUT" '.data | {success: true, appId, name, url: ("https://apps.crewlyai.com/" + .appId), version, created, notified} + '"$CARD_JQ"'
     + (if .publicRequested == true then {publicRequested: true, message: $msg} elif .publicRequested == false then {publicRequested: false, publicError} else {} end)
-    + (if .publicPaused == true then {publicPaused: true, publicPausedMessage} else {} end)'
+    + (if .publicPaused == true then {publicPaused: true, publicPausedMessage} else {} end) + $own'
 else
   printf '%s' "$RESP" | jq -c --arg code "$CODE" '{success: false, status: ($code|tonumber), reason: (.error // "unknown"), message: (.message // ""), hint: (.hint // "")}' 2>/dev/null \
     || jq -cn --arg code "$CODE" '{success: false, status: ($code|tonumber? // 0), reason: "http_error"}'

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

@@ -63,6 +63,10 @@ class H(BaseHTTPRequestHandler):
             return send(200, {'success': True, 'data': {'appId': 'bcdfghjkmn', 'captured': False, 'reason': 'no_browser', 'message': 'No Chrome'}})
         if self.path == '/api/apps/28au74d9cj/make-private':
             return send(200, {'success': True, 'data': {'appId': '28au74d9cj', 'visibility': 'private'}})
+        if self.path.endswith('/owner') and method == 'PUT':
+            if data.get('owner') == 'channel:#nope':
+                return send(400, {'success': False, 'error': 'validation', 'message': 'No channel "#nope" on this machine.'})
+            return send(200, {'success': True, 'data': {'appId': '28au74d9cj', 'owner': {'kind': 'channel', 'explicit': True, 'name': '#daily-brief'}, 'previous': None}})
         if self.path == '/api/apps/28au74d9cj/transfer':
             return send(200, {'success': True, 'data': {'appId': '28au74d9cj', 'name': 'G', 'publisher': data['toSession'], 'previous': 'dev-ella', 'changed': True, 'notified': [data['toSession']]}})
         if self.path.endswith('/rollback'):
@@ -79,6 +83,9 @@ class H(BaseHTTPRequestHandler):
     def do_POST(self):
         n = int(self.headers.get('content-length', '0')); body = self.rfile.read(n).decode() if n else ''
         self._reply('POST', json.loads(body or '{}'))
+    def do_PUT(self):
+        n = int(self.headers.get('content-length', '0')); body = self.rfile.read(n).decode() if n else ''
+        self._reply('PUT', json.loads(body or '{}'))
     def log_message(self, *a, **k): pass
 HTTPServer(('127.0.0.1', PORT), H).serve_forever()
 PY
@@ -220,5 +227,16 @@ check "refresh-thumbnail without a browser" "$OUT" '{"success":false,"appId":"bc
 OUT=$(run_err --dir "$APPDIR" --refresh-thumbnail || true)
 check "--refresh-thumbnail is not a publish option" "$(printf '%s' "$OUT" | grep -c 'act on an app')" "1"
 
+# --owner (crewly-services apps/SPEC.md §15)
+OUT=$(run --app 28au74d9cj --owner 'channel:#daily-brief')
+check "owner alone: output" "$OUT" '{"success":true,"appId":"28au74d9cj","owner":{"kind":"channel","name":"#daily-brief","default":false}}'
+check "owner alone: request" "$(jq -c '{method, path, body}' "$STUB_LOG")" '{"method":"PUT","path":"/api/apps/28au74d9cj/owner","body":{"owner":"channel:#daily-brief"}}'
+check "owner alone needs --app" "$(run_err --owner 'team:dev' | grep -c -- '--app is required with --owner')" "1"
+OUT=$(run --dir "$APPDIR" --owner 'channel:#daily-brief')
+check "publish + owner: set after the publish" "$(printf '%s' "$OUT" | jq -c '{success, owner}')" '{"success":true,"owner":{"kind":"channel","name":"#daily-brief","default":false}}'
+check "publish + owner: last request is the owner change" "$(jq -r '.method + " " + .path' "$STUB_LOG")" "PUT /api/apps/28au74d9cj/owner"
+OUT=$(run --dir "$APPDIR" --owner 'channel:#nope')
+check "publish + bad owner: publish still succeeds, ownerError says why" "$(printf '%s' "$OUT" | jq -c '{success, ownerError}')" '{"success":true,"ownerError":"No channel \"#nope\" on this machine."}'
+
 echo "publish-app: $PASS passed, $FAIL failed"
 [ "$FAIL" -eq 0 ]