### server instructions
You are a member of a file-based organization of agents. Your identity is fixed by the runtime.
Work flows down as tasks (delegate), results flow up (report), everything else is a note (send).
Call whoami first if you do not know your role, reports, budget and open tasks.


### tool: whoami
input: {
  "properties": {},
  "title": "whoamiArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "whoamiOutput",
  "type": "object"
}
other: {}
description:
Your address, role, budget, direct reports, open tasks, outstanding delegations and charter.

### tool: inbox
input: {
  "properties": {},
  "title": "inboxArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "inboxOutput",
  "type": "object"
}
other: {}
description:
The messages for this run. For root (the human) this lists unread messages and marks them read.

### tool: delegate
input: {
  "properties": {
    "to": {
      "title": "To",
      "type": "string"
    },
    "title": {
      "title": "Title",
      "type": "string"
    },
    "goal": {
      "title": "Goal",
      "type": "string"
    },
    "acceptance": {
      "title": "Acceptance",
      "type": "string"
    },
    "inputs": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Inputs"
    },
    "budget": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Budget"
    },
    "revises": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Revises"
    }
  },
  "required": [
    "to",
    "title",
    "goal",
    "acceptance"
  ],
  "title": "delegateArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "delegateOutput",
  "type": "object"
}
other: {}
description:
Assign a task to one of your direct reports.

        to: the report's address (e.g. "ceo/cto"). title: a few words. goal: what outcome is needed and why.
        acceptance: concrete, checkable criteria for "done". inputs: paths (relative to the org root) the
        report should read. budget: runs handed to the report from your own budget. If you omit it, the default is
        min(default_budget from ORG.md, your budget - reserve), where the reserve keeps one run per outstanding
        delegation plus one for this one; if that is below 1 the call fails and tells you your options.
        An explicit budget must leave that same reserve.
        Copy the relevant acceptance criteria verbatim from the task you are working on; never paraphrase or relax them.
        revises: when sending work back for rework, the id of the earlier task you sent to the same report.
        Returns the task id. Do not wait for the result: end your run, the result will wake you.
        

### tool: report
input: {
  "properties": {
    "task_id": {
      "title": "Task Id",
      "type": "string"
    },
    "status": {
      "title": "Status",
      "type": "string"
    },
    "summary": {
      "title": "Summary",
      "type": "string"
    },
    "artifacts": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Artifacts"
    },
    "lessons": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Lessons"
    }
  },
  "required": [
    "task_id",
    "status",
    "summary"
  ],
  "title": "reportArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "reportOutput",
  "type": "object"
}
other: {}
description:
Answer a task assigned to you. Goes to whoever assigned it.

        status: "done" (every acceptance criterion verifiably met), "failed", or "blocked" (say what would unblock it).
        `done` and `failed` are final: a second report is refused. `blocked` is not: once the blocker is resolved
        you may report the task again, once per blocked report (any status; the new report supersedes the old one),
        under the same rules. A `send` note never changes a task's outcome and must not claim criteria are met.
        summary: at most ~10 lines; this is all your manager reads by default. artifacts: paths of the
        files that hold the work; they must exist. Files in the organization: path relative to the org root.
        Files in your workspace: the ABSOLUTE path (anything else outside the organization is refused). The runtime
        annotates each with its word count and whether it changed since the task was assigned.
        lessons: required when the task is a request for a service, whatever the status - done, failed or blocked
        (1-3 lines, at most 800 characters: what worked or went wrong, what to change in the playbook, the evidence:
        runs, rework, review findings); it is recorded in the result and reviewed before the next request. Optional
        otherwise.
        

### tool: send
input: {
  "properties": {
    "to": {
      "title": "To",
      "type": "string"
    },
    "body": {
      "title": "Body",
      "type": "string"
    },
    "title": {
      "default": "",
      "title": "Title",
      "type": "string"
    },
    "reply_to": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Reply To"
    },
    "budget": {
      "default": 0,
      "title": "Budget",
      "type": "integer"
    }
  },
  "required": [
    "to",
    "body"
  ],
  "title": "sendArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "sendOutput",
  "type": "object"
}
other: {}
description:
Send a note: a question, information, or an escalation.

        Allowed recipients: your parent, your direct reports, your siblings, or the sender of the message
        you reply to (set reply_to to its id). budget: runs to move along with the note (optional): extra runs
        granted to a direct report, or unneeded runs given back to your PARENT (never to a sibling). Runs you
        have left return to your parent by themselves with your final `done`/`failed` report when nothing else
        is open for you; use this only to give some back earlier. To pull unspent runs BACK from an idle direct
        report instead (budget stranded in a team that cannot use it), use `reclaim`.
        

### tool: reclaim
input: {
  "properties": {
    "report": {
      "title": "Report",
      "type": "string"
    },
    "budget": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Budget"
    }
  },
  "required": [
    "report"
  ],
  "title": "reclaimArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "reclaimOutput",
  "type": "object"
}
other: {}
description:
Pull unspent budget back from one of your DIRECT reports (a manager from its team; root from its top agents).

        report: its short name or address. budget: how many runs (default: all it has left). Only an idle report:
        no open task, nothing delegated and outstanding, not running, no unread mail that would wake it; otherwise the
        call is refused and says why. Not from deeper down (a manager reclaims from its own reports). The report is
        not woken and gets no message; you get the runs (they join your budget at once, and then a delegation or
        `send(..., budget=N)` can move them to whoever needs them). Use it before asking your parent for more runs
        while a sibling team sits on unspent ones.
        

### tool: hire
input: {
  "properties": {
    "name": {
      "title": "Name",
      "type": "string"
    },
    "role": {
      "title": "Role",
      "type": "string"
    },
    "charter": {
      "title": "Charter",
      "type": "string"
    },
    "model": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Model"
    },
    "tools": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Tools"
    },
    "can_hire": {
      "default": false,
      "title": "Can Hire",
      "type": "boolean"
    },
    "max_children": {
      "default": 5,
      "title": "Max Children",
      "type": "integer"
    },
    "workspace": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Workspace"
    },
    "inputs": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Inputs"
    }
  },
  "required": [
    "name",
    "role",
    "charter"
  ],
  "title": "hireArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "hireOutput",
  "type": "object"
}
other: {}
description:
Create a direct report (only if your charter allows hiring).

        name: lowercase-dashed (becomes the address <you>/<name>). role: a short job title.
        charter: markdown with purpose, responsibilities, decision rights, what to escalate, quality bar.
        model: kiro model id (optional; unset = the organization's default model, claude-sonnet-5.5). tools: kiro built-in tools to grant, only ones you have yourself
        (e.g. "read", "write", "shell"). can_hire: whether the report may build its own team.
        workspace: directory the report works in (must be inside yours).
        inputs: absolute folders the report may only READ (never change); a manager can give only folders inside its
        own inputs or workspace. A report with `read` and no workspace/inputs reads nothing outside the org.
        A new report has no budget until you delegate a task to it.
        

### tool: retire
input: {
  "properties": {
    "name": {
      "title": "Name",
      "type": "string"
    },
    "reason": {
      "title": "Reason",
      "type": "string"
    }
  },
  "required": [
    "name",
    "reason"
  ],
  "title": "retireArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "retireOutput",
  "type": "object"
}
other: {}
description:
Remove a direct report and its team (name: its short name or full address, e.g. "eng" or "ceo/eng").

        Their open tasks are reported to you as failed, and the team's unspent budget is returned to you.
        

### tool: read
input: {
  "properties": {
    "path": {
      "default": ".",
      "title": "Path",
      "type": "string"
    }
  },
  "title": "readArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "readOutput",
  "type": "object"
}
other: {}
description:
The ORGANIZATION's read tool (kiro shows it as @hirearchy/read; not kiro's built-in `read`, which reads the
        workspace). Reads a file (with word count and modification time) or lists a directory in the organization. Paths
        are relative to the org root, e.g. "ceo/writer/work/brief.md". Outside the organization only ABSOLUTE paths work,
        and only inside your workspace, your read-only inputs, or the workspace of an agent in your team (to verify
        what your reports made); anything else is refused.

### tool: org_write
input: {
  "properties": {
    "path": {
      "title": "Path",
      "type": "string"
    },
    "content": {
      "title": "Content",
      "type": "string"
    },
    "append": {
      "default": false,
      "title": "Append",
      "type": "boolean"
    }
  },
  "required": [
    "path",
    "content"
  ],
  "title": "writeArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "writeOutput",
  "type": "object"
}
other: {}
description:
Write an ORGANIZATION file (kiro shows this tool as @hirearchy/org_write; it is NOT kiro's built-in `write`, which
        writes the workspace). kiro's built-in `write` has the name `write`; this hirearchy tool is called `org_write` for you. Use it for your memory, notes and artifacts inside your own org directory. Paths are
        relative to the org root, like every path here, so they start with your address: e.g. "<you>/MEMORY.md" or
        "<you>/work/plan.md".

        You may also rewrite a direct report's charter ("<you>/<name>/AGENT.md"). Inboxes, logs and your own
        charter are managed by the runtime; use send/delegate/report to communicate. A charter rewrite keeps every
        frontmatter key (tools, inputs, model, ...) that your new text does not set; the reply lists what was kept
        and what changed.
        

### tool: status
input: {
  "properties": {},
  "title": "statusArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "statusOutput",
  "type": "object"
}
other: {}
description:
The whole organization as a tree: each agent's role, state, budget and workload.

### tool: health
input: {
  "properties": {
    "agent": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Agent"
    }
  },
  "title": "healthArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "healthOutput",
  "type": "object"
}
other: {}
description:
Health report (stuck, expensive, low-quality, wasteful, idle, paused) for an agent and its subtree.

        agent: yourself or an agent in your own subtree (root may ask about anyone). Default: your own subtree
        (root: the whole organization). Use it to decide whom to follow up with, rework, re-budget or retire.
        
