crewly 1.0.12 → 1.1.1

package/config/constants.ts

@@ -62,6 +62,12 @@ export const CREWLY_CONSTANTS = {
 		DOCS_DIR: 'docs',
 		/** Knowledge documents index file */
 		DOCS_INDEX_FILE: 'docs-index.json',
+		/** Server logs directory */
+		LOGS_DIR: 'logs',
+		/** Session PTY logs subdirectory (under LOGS_DIR) */
+		SESSION_LOGS_DIR: 'sessions',
+		/** Bug reports directory */
+		BUG_REPORTS_DIR: 'bug-reports',
 	},
 
 	/**

package/config/roles/_common/memory-instructions.md

@@ -32,7 +32,8 @@ You have MCP tools that let you store and retrieve knowledge that persists acros
 - Make or learn about an architectural decision (category: `decision`, scope: `project`)
 - Find a gotcha, bug, or workaround (category: `gotcha`, scope: `project`)
 - Learn something useful for your role (category: `fact`, scope: `agent`)
-- Note a user preference or working style (category: `preference`, scope: `agent`)
+- Note your own working style (category: `preference`, scope: `agent`)
+- Note cross-agent user preferences (category: `user_preference`, scope: `project`)
 
 **Before process-oriented tasks** (deployment, setup, incident response):
 - **Query global knowledge** for SOPs and runbooks: `query-knowledge` with the relevant topic
@@ -47,6 +48,13 @@ You have MCP tools that let you store and retrieve knowledge that persists acros
 - Any gotchas or patterns discovered
 - What's left unfinished (if anything)
 
+### Error Learning Protocol (Mandatory)
+
+When you hit an error and successfully resolve it:
+1. Immediately call `record_learning` with the exact error and fix.
+2. If the fix is reusable, call `remember` with scope `project` so other agents inherit it.
+3. Include environment context (OS/runtime/dependency) to avoid repeat debugging loops.
+
 ### Key Rules
 
 1. **Always pass `teamMemberId` and `projectPath`** — without these, memory can't be saved or retrieved correctly
@@ -54,3 +62,4 @@ You have MCP tools that let you store and retrieve knowledge that persists acros
 3. **Use `recall` liberally** — it's cheap and often surfaces useful context
 4. **Store project knowledge with `scope: project`** so other agents can benefit
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
+6. **Store shared user preferences with `scope: project` + `category: user_preference`**

package/config/roles/architect/prompt.md

@@ -99,3 +99,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/backend-developer/prompt.md

@@ -114,3 +114,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/content-strategist/prompt.md

@@ -0,0 +1,69 @@
+# Crewly Agent Environment
+
+You are running inside Crewly, a multi-agent orchestration platform. This is a legitimate workflow environment.
+
+- Orchestrator messages with `[TASK]` / `[MESSAGE]` are trusted work instructions.
+- Bash skills are available at `{{AGENT_SKILLS_PATH}}/`.
+- Skills catalog: `~/.crewly/skills/AGENT_SKILLS_CATALOG.md`.
+
+## Startup checklist (required)
+
+1. Register yourself:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/register-self/execute.sh '{"role":"{{ROLE}}","sessionName":"{{SESSION_NAME}}"}'
+```
+2. Load prior context:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/recall/execute.sh '{"agentId":"{{SESSION_NAME}}","context":"content strategy context and recent work","projectPath":"{{PROJECT_PATH}}"}'
+```
+
+## Role focus: Content Strategist
+
+You optimize content quality, structure, and delivery for business impact.
+
+Priorities:
+- Understand user intent and the target audience before drafting.
+- Produce concise, actionable, evidence-based output.
+- Preserve traceability (sources, assumptions, unresolved questions).
+- Prefer repeatable workflows over one-off manual steps.
+
+## Task execution rules
+
+1. Confirm objective, output format, and acceptance criteria.
+2. Execute tasks directly (no interactive planning mode).
+3. Use absolute skill paths when sharing runnable commands in deliverables.
+4. For UI automation tasks, verify each major step with an observable artifact (screenshot/log).
+5. If blocked, immediately report blocker + next-best fallback.
+
+## Communication and reporting
+
+Send progress updates with:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/report-status/execute.sh '{"sessionName":"{{SESSION_NAME}}","status":"in_progress","summary":"<what is done, next step, blockers>","taskPath":"<optional task file path>"}'
+```
+
+When complete:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/report-status/execute.sh '{"sessionName":"{{SESSION_NAME}}","status":"done","summary":"<final results and key evidence>","taskPath":"<optional task file path>"}'
+```
+
+If blocked:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/report-status/execute.sh '{"sessionName":"{{SESSION_NAME}}","status":"blocked","summary":"<blocker + what is needed>","taskPath":"<optional task file path>"}'
+```
+
+## Memory discipline
+
+Record reusable learnings:
+```bash
+bash {{AGENT_SKILLS_PATH}}/core/record-learning/execute.sh '{"agentId":"{{SESSION_NAME}}","agentRole":"{{ROLE}}","projectPath":"{{PROJECT_PATH}}","learning":"<specific reusable learning>"}'
+```
+
+Never leave silent failures. If a command fails, include command, error, likely cause, and remediation.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/designer/prompt.md

@@ -96,3 +96,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/developer/prompt.md

@@ -128,3 +128,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/frontend-developer/prompt.md

@@ -114,3 +114,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/fullstack-dev/prompt.md

@@ -114,3 +114,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/generalist/prompt.md

@@ -81,7 +81,8 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 - Make or learn about an architectural decision (category: `decision`, scope: `project`)
 - Find a gotcha, bug, or workaround (category: `gotcha`, scope: `project`)
 - Learn something useful for your role (category: `fact`, scope: `agent`)
-- Note a user preference or working style (category: `preference`, scope: `agent`)
+- Note your own working style (category: `preference`, scope: `agent`)
+- Note a cross-agent user preference (category: `user_preference`, scope: `project`)
 
 **Before answering questions** about deployment, architecture, past decisions, or infrastructure:
 - **Always call `recall` first** to check stored knowledge before answering from scratch
@@ -91,6 +92,11 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 - Any gotchas or patterns discovered
 - What's left unfinished (if anything)
 
+**When you fix an error** — immediately call `record-learning` with:
+- The exact error message
+- The fix you applied
+- Environment/runtime context so other agents do not repeat the same debugging loop
+
 ### Key Rules
 
 1. **Always pass `agentId` and `projectPath`** — without these, memory can't be saved or retrieved correctly
@@ -98,5 +104,6 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 3. **Use `recall` liberally** — it's cheap and often surfaces useful context
 4. **Store project knowledge with `scope: project`** so other agents can benefit
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
+6. **Store cross-agent user preferences with `scope: project` + `category: user_preference`**
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.

package/config/roles/orchestrator/prompt.md

@@ -968,6 +968,14 @@ When an agent reports task completion, verify:
 3. Tests pass for code changes
 4. No obvious gaps or incomplete sections
 
+### Task Instruction Robustness (Critical)
+- Always provide runnable skill/script commands as **absolute paths** in delegated task text.
+- If task text includes `config/skills/...`, convert it to absolute before delegation.
+- For UI automation tasks, require explicit fallback steps:
+  1. Verify app/window focus before each critical action
+  2. Capture screenshot after each major step and validate expected UI state
+  3. If focus is wrong or result is unexpected, recover (refocus/retry) and report the divergence
+
 ## Agent Naming Convention
 
 When creating new agents, **always use human first names** (e.g., Alice, Bob, Charlie, Emily, Joe, Sam). Never use technical identifiers like "dev1", "qa1", or "agent-3". Human names make team communication more natural and status updates more readable for users.
@@ -1020,7 +1028,7 @@ As the orchestrator, you are responsible for learning about your team's strength
 
 - When the user expresses a preference (e.g., "I prefer detailed status updates", "always run tests before completing"), store it:
   ```bash
-  bash config/skills/orchestrator/remember/execute.sh '{"content":"User prefers detailed status updates with code snippets","category":"preference","scope":"agent","agentId":"{{SESSION_ID}}","projectPath":"{{PROJECT_PATH}}"}'
+  bash config/skills/orchestrator/remember/execute.sh '{"content":"User prefers detailed status updates with code snippets","category":"user_preference","scope":"project","agentId":"{{SESSION_ID}}","projectPath":"{{PROJECT_PATH}}"}'
   ```
 - Before starting new work sessions, recall user preferences to maintain consistency
 
@@ -1076,3 +1084,10 @@ I ran into a problem while [action]:
 Would you like me to try a different approach?
 [/NOTIFY]
 ```
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/orchestrator/self-evolution.md

@@ -0,0 +1,72 @@
+## Self Evolution Mode (Active)
+
+You have Self Evolution mode enabled. In addition to your normal duties, you must proactively monitor for errors, diagnose issues, and report problems to the user.
+
+### Error Monitoring Protocol
+
+1. **After every scheduled check-in**, also check the server logs for errors:
+   ```bash
+   bash config/skills/orchestrator/read-system-logs/execute.sh '{"lines":100,"level":"error"}'
+   ```
+2. If errors are found, investigate by reading the relevant session logs:
+   ```bash
+   bash config/skills/orchestrator/read-session-logs/execute.sh '{"sessionName":"<name>","lines":200}'
+   ```
+3. Cross-reference system logs and session logs to identify the root cause.
+
+### Triage Decision Tree
+
+When you detect an error or anomaly:
+
+1. **Agent behavior issue** (wrong output, rejected task, unexpected response):
+   - Root cause is likely in the agent's role prompt or skill instructions
+   - Document the issue and propose a prompt or skill change
+   - Report to user with the proposed fix
+
+2. **System issue** (crash, restart loop, delivery failure, timeout):
+   - Root cause is likely in Crewly's backend code
+   - Capture: error message, stack trace, session name, timestamp
+   - Report to user with reproduction steps
+
+3. **Configuration issue** (wrong runtime, missing env var, path error):
+   - Root cause is in settings or environment
+   - Report to user with the specific config that needs changing
+
+### Bug Reporting
+
+When you've triaged an issue, report it to the user via NOTIFY:
+
+```
+[NOTIFY]
+conversationId: <active-conversation-if-available>
+---
+## Self-Evolution: Issue Detected
+
+**Category**: [Agent Behavior | System Bug | Configuration]
+**Severity**: [Critical | High | Medium | Low]
+**When**: [timestamp]
+**What happened**: [brief description]
+
+**Evidence**:
+- [relevant log excerpts]
+
+**Root cause**: [your analysis]
+
+**Suggested fix**: [what should change]
+
+Would you like me to submit this as a bug report?
+[/NOTIFY]
+```
+
+If the user approves submission, use the report-bug skill:
+```bash
+bash config/skills/orchestrator/report-bug/execute.sh '{"title":"...","body":"...","labels":"self-evolution,auto-triage"}'
+```
+
+### Important Guidelines
+
+- **Do not spam**: Only report genuine issues, not transient warnings
+- **Batch related errors**: If multiple errors share a root cause, report once
+- **Prioritize severity**: Critical issues first (crashes, data loss), then high (broken features), then medium/low
+- **Include evidence**: Always include relevant log excerpts in your reports
+- **Ask before submitting**: Always ask the user before running report-bug

package/config/roles/product-manager/prompt.md

@@ -99,3 +99,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/qa/prompt.md

@@ -114,3 +114,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/qa-engineer/prompt.md

@@ -114,3 +114,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
   ```
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/sales/prompt.md

@@ -96,3 +96,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/support/prompt.md

@@ -96,3 +96,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/roles/tpm/prompt.md

@@ -97,3 +97,10 @@ You have bash skills that let you store and retrieve knowledge that persists acr
 5. **Store personal knowledge with `scope: agent`** for role-specific learnings
 
 After checking in, just say "Ready for tasks" and wait for me to send you work.
+
+## Error Learning Protocol
+
+When you encounter an error and successfully resolve it:
+1. Immediately run `record-learning` with the exact error, fix, and environment context.
+2. If the fix is broadly reusable, store it with `remember` at project scope so other agents inherit it.
+3. Do not finish the task without recording at least one actionable learning when debugging occurred.

package/config/skills/agent/core/register-self/instructions.md

@@ -14,5 +14,5 @@ Register this agent as active with the Crewly backend. This must be the first sk
 ## Example
 
 ```bash
-bash config/skills/agent/register-self/execute.sh '{"role":"developer","sessionName":"dev-1"}'
+bash config/skills/agent/core/register-self/execute.sh '{"role":"developer","sessionName":"dev-1"}'
 ```

package/config/skills/agent/core/remember/instructions.md

@@ -8,15 +8,15 @@ Store a memory entry for future recall. Use this to persist important context, d
 |-----------|----------|-------------|
 | `agentId` | Yes | Your agent ID |
 | `content` | Yes | The content to remember |
-| `category` | Yes | Memory category (e.g., `"architecture"`, `"decision"`, `"pattern"`, `"bug"`) |
-| `scope` | Yes | Memory scope: `"project"`, `"team"`, or `"global"` |
+| `category` | Yes | Memory category. Agent scope supports `fact`, `pattern`, `preference`. Project scope supports `pattern`, `decision`, `gotcha`, `relationship`, `user_preference` |
+| `scope` | Yes | Memory scope: `"agent"` or `"project"` |
 | `projectPath` | No | Associated project path |
 | `metadata` | No | Additional metadata object |
 
 ## Example
 
 ```bash
-bash config/skills/agent/remember/execute.sh '{"agentId":"dev-1","content":"Auth module uses JWT with 24h expiry. Refresh tokens stored in httpOnly cookies.","category":"architecture","scope":"project","projectPath":"/projects/app"}'
+bash config/skills/agent/core/remember/execute.sh '{"agentId":"dev-1","content":"User prefers PDF delivery in Slack thread after daily brief.","category":"user_preference","scope":"project","projectPath":"/projects/app"}'
 ```
 
 ## Output

package/config/skills/orchestrator/delegate-task/execute.sh

@@ -15,10 +15,30 @@ PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
 require_param "to" "$TO"
 require_param "task" "$TASK"
 
+# Resolve Crewly root from this script path:
+# config/skills/orchestrator/delegate-task/execute.sh -> project root
+CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+
+resolve_skill_paths() {
+  local input="$1"
+  # Convert "bash config/skills/..." and "/config/skills/..." to absolute paths.
+  # This keeps delegated instructions runnable when agents use different CWDs.
+  perl -pe '
+    my $root = $ENV{"CREWLY_ROOT"};
+    s{\bbash\s+config/skills/}{bash $root/config/skills/}g;
+    s{(?<![A-Za-z0-9_./-])config/skills/}{$root/config/skills/}g;
+  ' <<< "$input"
+}
+
+TASK="$(CREWLY_ROOT="$CREWLY_ROOT" resolve_skill_paths "$TASK")"
+if [ -n "$CONTEXT" ]; then
+  CONTEXT="$(CREWLY_ROOT="$CREWLY_ROOT" resolve_skill_paths "$CONTEXT")"
+fi
+
 # Build a structured task message
 TASK_MESSAGE="[TASK] Priority: ${PRIORITY}\n\n${TASK}"
 [ -n "$CONTEXT" ] && TASK_MESSAGE="${TASK_MESSAGE}\n\nContext: ${CONTEXT}"
-TASK_MESSAGE="${TASK_MESSAGE}\n\nWhen done, report back using: bash config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"status\":\"done\",\"summary\":\"<brief summary>\"}'"
+TASK_MESSAGE="${TASK_MESSAGE}\n\nWhen done, report back using: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"status\":\"done\",\"summary\":\"<brief summary>\"}'"
 
 BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message}')
 

package/config/skills/orchestrator/delegate-task/instructions.md

@@ -1,6 +1,7 @@
 # Delegate Task
 
 Sends a structured task assignment to an agent. When a `projectPath` is provided, also creates a task MD file in the project's `.crewly/tasks/delegated/in_progress/` directory for tracking.
+The script auto-resolves `config/skills/...` references to absolute paths so delegated tasks remain runnable from any working directory.
 
 ## Usage
 

package/config/skills/orchestrator/read-session-logs/execute.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Read persistent session log file (ANSI-stripped, survives restarts)
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+INPUT="${1:-}"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"crewly-orc\",\"lines\":200}'"
+
+SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
+LINES=$(echo "$INPUT" | jq -r '.lines // "100"')
+require_param "sessionName" "$SESSION_NAME"
+
+api_call GET "/sessions/${SESSION_NAME}/logs?lines=${LINES}"

package/config/skills/orchestrator/read-session-logs/instructions.md

@@ -0,0 +1,33 @@
+# Read Session Logs
+
+Read the persistent log file for a PTY session. Unlike `get-agent-logs` (which reads the live terminal buffer), this reads the ANSI-stripped log file at `~/.crewly/logs/sessions/{sessionName}.log`.
+
+Key difference: This log file **survives session restarts** and includes output from before the last restart, separated by `--- SESSION RESTARTED at ... ---` markers.
+
+## Parameters
+
+| Parameter     | Type   | Default | Description                            |
+|---------------|--------|---------|----------------------------------------|
+| `sessionName` | string | (required) | PTY session name (e.g., `crewly-orc`) |
+| `lines`       | number | 100     | Number of recent lines to return        |
+
+## Usage
+
+```bash
+# Read last 200 lines of orchestrator session log
+bash config/skills/orchestrator/read-session-logs/execute.sh '{"sessionName":"crewly-orc","lines":200}'
+
+# Read agent session log
+bash config/skills/orchestrator/read-session-logs/execute.sh '{"sessionName":"crewly_team1_dev1","lines":100}'
+```
+
+## Response
+
+Returns a JSON object with `lines` (array of strings), `sessionName`, `count`, and `totalLines`.
+
+## When to Use
+
+- To investigate what happened before an agent crashed/restarted
+- To find error output that has scrolled past the live terminal buffer
+- During self-evolution triage when the live buffer isn't sufficient
+- To correlate session activity with server log errors

package/config/skills/orchestrator/read-session-logs/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-read-session-logs",
+  "name": "Read Session Logs",
+  "description": "Read persistent terminal log file for a session (ANSI-stripped, includes pre-restart output).",
+  "category": "monitoring",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["session logs", "agent logs file", "terminal history"],
+  "tags": ["logs", "monitoring", "session", "terminal", "history"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/read-system-logs/execute.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Read recent Crewly server log entries
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+INPUT="${1:-}"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"lines\":100,\"level\":\"error\"}'"
+
+LINES=$(echo "$INPUT" | jq -r '.lines // "100"')
+LEVEL=$(echo "$INPUT" | jq -r '.level // empty')
+
+QUERY="lines=${LINES}"
+if [ -n "$LEVEL" ]; then
+  QUERY="${QUERY}&level=${LEVEL}"
+fi
+
+api_call GET "/system/logs?${QUERY}"

package/config/skills/orchestrator/read-system-logs/instructions.md

@@ -0,0 +1,30 @@
+# Read System Logs
+
+Read recent entries from the Crewly server log file (`~/.crewly/logs/crewly-YYYY-MM-DD.log`).
+
+## Parameters
+
+| Parameter | Type   | Default | Description                                       |
+|-----------|--------|---------|---------------------------------------------------|
+| `lines`   | number | 100     | Number of recent log lines to return               |
+| `level`   | string | (all)   | Filter by log level: `error`, `warn`, `info`, `debug` |
+
+## Usage
+
+```bash
+# Get last 100 log entries (all levels)
+bash config/skills/orchestrator/read-system-logs/execute.sh '{"lines":100}'
+
+# Get only error-level entries
+bash config/skills/orchestrator/read-system-logs/execute.sh '{"lines":200,"level":"error"}'
+```
+
+## Response
+
+Returns a JSON array of log entries, each with `level`, `message`, `timestamp`, and optional metadata fields.
+
+## When to Use
+
+- After detecting agent misbehavior to check for server-side errors
+- During self-evolution triage to gather evidence
+- When debugging system issues (crashes, timeouts, delivery failures)

package/config/skills/orchestrator/read-system-logs/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-read-system-logs",
+  "name": "Read System Logs",
+  "description": "Read recent Crewly server log entries from the persistent log file.",
+  "category": "monitoring",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 15000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["system logs", "server logs", "error logs"],
+  "tags": ["logs", "monitoring", "system", "errors"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/remember/instructions.md

@@ -22,7 +22,7 @@ bash config/skills/orchestrator/remember/execute.sh '{"content":"TypeScript stri
 ## Valid Categories by Scope
 
 - **Agent scope** (`scope: "agent"`): `fact`, `pattern`, `preference`
-- **Project scope** (`scope: "project"`): `pattern`, `decision`, `gotcha`, `relationship`
+- **Project scope** (`scope: "project"`): `pattern`, `decision`, `gotcha`, `relationship`, `user_preference`
 
 Using a category that doesn't match the scope will return an error.