### server instructions
You are connected to ONE hirearchy organization as `root`, the human's seat. No organization exists and none is bound: the first step is create_org(mission=..., path=<absolute path>), after which all tools work.
- Use only this organization: never look for, create or modify another (no other paths or ORG_ROOT).
- Never claim the organization did work unless hirearchy tools show it.
- If a hirearchy tool fails, tell the user instead of substituting another mechanism.
- `whoami` and `status` show the state; `start`/`stop` control the scheduler. `observe` (read-only): what ran or failed.
- Services: `services` (check it before building a new org), `request`, `feedback` (rate a delivery), `define_service`.
When the user asks for an org, team or agents for a goal:
1. Ask what you need in ONE message. Propose defaults only where a generic one exists; ASK for any list not
   given (scope items, source files), never invent. Default deliverable place: a new
   `deliverables/` folder in the current directory (say so). Also ask: format, length, exact checkable criteria,
   sources/web, workspace and tests (code), budget in runs, models (all claude-sonnet-5.5; if cheaper: keep the lead and final verifier strong;
   the lead decides how every other run is spent), review, approval.
2. Start the blueprint from `blueprint_example(kind)` (`service=True` for recurring work), then `propose_org`. Show the
   "PLAN FOR YOU" block exactly as returned. Fix errors; settle its warnings (e.g. model policy) with the user
   or state them; wait for approval. The user's own files go in `needs.inputs` (read-only);
   built-in `write` only for code.
3. After approval: `create_org` (if none exists), `apply_org(blueprint, approved=True, plan_id=<from propose_org>)`,
   `start`. Spend beyond the plan needs their OK: ask at the FIRST budget request, not after the reserve is gone;
   first check `status` for stranded runs and `reclaim` them (or tell the lead to).
4. Answer "status?" with `progress`. Never promise to tell the user later (your turn ends at the reply): to be told when
   it is done, say you will wait now and call `progress(wait_seconds=N)`, repeat if asked; else tell them to ask
   "status?". Relay escalations with a recommendation.
5. When it is done: read the deliverable and check it against EVERY acceptance criterion (send it back with
   `delegate(..., revises=...)` if not; never patch it yourself), copy it where they want it. `start` ends by
   itself when the work is done (start again for more work); `stop` only if the user cancels, declines
   more budget or you hand over an unverified result (say the task stays open). Final answer: as short as asked.


### 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: 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/write; it is NOT kiro's built-in `write`, which
        writes the workspace). 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.
        

### tool: services
input: {
  "properties": {},
  "title": "servicesArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "servicesOutput",
  "type": "object"
}
other: {}
description:
The standing services you can request from your direct reports and the ones you offer, with contract and
        playbook versions, inputs, budget per request and the record so far (requests, outcomes, runs, feedback).

### tool: define_service
input: {
  "properties": {
    "owner": {
      "title": "Owner",
      "type": "string"
    },
    "name": {
      "title": "Name",
      "type": "string"
    },
    "description": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Description"
    },
    "acceptance": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Acceptance"
    },
    "deliverable": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Deliverable"
    },
    "budget": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Budget"
    },
    "inputs": {
      "anyOf": [
        {
          "items": {
            "additionalProperties": true,
            "type": "object"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Inputs"
    },
    "playbook": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Playbook"
    },
    "locked": {
      "anyOf": [
        {
          "type": "boolean"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Locked"
    },
    "notes": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Notes"
    },
    "add_acceptance": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Add Acceptance"
    },
    "remove_acceptance": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Remove Acceptance"
    }
  },
  "required": [
    "owner",
    "name"
  ],
  "title": "define_serviceArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "define_serviceOutput",
  "type": "object"
}
other: {}
description:
Define a standing service of one of your direct reports (root: a top-level agent), or amend its contract.

        You are the client: the contract is yours; the owner cannot change it. owner: the report. name: lowercase-dashed,
        unique among your reports' services. FIRST definition needs description (one line), acceptance (concrete,
        checkable criteria that travel with every request), deliverable ({description, format?, max_words?, path?
        (absolute)}) and budget (runs handed down with each request); optional: inputs ([{name, description, required
        (default true)}] the requester fills in), playbook (markdown workflow, first definition only), locked (true = the
        owner may not revise the playbook), notes (free text for the owner).
        AMENDMENT (the service exists): pass only what changes, the rest stays. To add a lasting requirement:
        `add_acceptance=[<criterion>]`; to drop one: `remove_acceptance=[<its exact text>]`; `acceptance` replaces
        all (not together with add/remove). The old contract is archived and the owner quietly told what changed; the
        reply lists the criteria now in force. An amendment that changes nothing is refused.
        

### tool: request
input: {
  "properties": {
    "service": {
      "title": "Service",
      "type": "string"
    },
    "inputs": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Inputs"
    },
    "title": {
      "default": "",
      "title": "Title",
      "type": "string"
    },
    "note": {
      "default": "",
      "title": "Note",
      "type": "string"
    },
    "extra_acceptance": {
      "anyOf": [
        {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Extra Acceptance"
    },
    "budget": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Budget"
    },
    "revises": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Revises"
    }
  },
  "required": [
    "service"
  ],
  "title": "requestArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "requestOutput",
  "type": "object"
}
other: {}
description:
Ask a direct report for one of its services (see `services`): a task built from the contract.

        inputs: {input name: value}; required ones must be present. note: free text for the owner. extra_acceptance:
        criteria added after the contract's (the contract's always apply). budget: runs handed down (default: the
        contract's; the usual reserve rule applies). revises: id of an earlier request of this service to send back for
        rework; the reply then states the case total (runs used by the whole chain, runs handed down, the contract's
        budget per request) and tells you to inform the user when the case exceeds that budget. Returns the task id;
        the result comes back like any result, then rate it with `feedback`.
        

### tool: feedback
input: {
  "properties": {
    "task_id": {
      "title": "Task Id",
      "type": "string"
    },
    "verdict": {
      "title": "Verdict",
      "type": "string"
    },
    "note": {
      "default": "",
      "title": "Note",
      "type": "string"
    }
  },
  "required": [
    "task_id",
    "verdict"
  ],
  "title": "feedbackArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "feedbackOutput",
  "type": "object"
}
other: {}
description:
Tell the owner of a service whether a delivered request was good: verdict "accept" or "reject".

        task_id: a service request (or rework) you sent that has a result. note: required for reject (what was wrong),
        optional for accept. It costs no run and does not wake the owner; it shows up in the evidence the owner reviews
        before its next request (and the moment a rejection arrives). Give it on your own judgement of each delivery,
        also on a rework: every verdict stays in the case's history, the latest one is the final verdict, and an
        earlier reject is still shown to the owner with your words. Feedback is for reflection only: it never waives an
        acceptance criterion or changes the outcome of the request.
        

### tool: observe
input: {
  "properties": {
    "view": {
      "default": "now",
      "title": "View",
      "type": "string"
    },
    "target": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Target"
    },
    "since": {
      "default": "24h",
      "title": "Since",
      "type": "string"
    },
    "by": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "By"
    },
    "errors_only": {
      "default": false,
      "title": "Errors Only",
      "type": "boolean"
    },
    "limit": {
      "default": 50,
      "title": "Limit",
      "type": "integer"
    }
  },
  "title": "observeArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "observeOutput",
  "type": "object"
}
other: {}
description:
Read-only look at how the organization is running. view=
        "now": what runs, what is queued and why, what waits on you, errors of the last 15 min.
        "trace" (target=root task id): every message, run, tool call and refusal of one request, with time spent
        queued, running and waiting on you. "metrics" (since=15m|24h|7d|ISO, by=agent|tool|service|trace): runs,
        failures, refusal rates, latency percentiles, budget spent. "events" (target=agent, trace id or kind,
        errors_only): the raw record. "check": is the runtime consistent (budget, messages, stuck runs)?

### tool: create_org
input: {
  "properties": {
    "mission": {
      "title": "Mission",
      "type": "string"
    },
    "default_model": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Default Model"
    },
    "path": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Path"
    }
  },
  "required": [
    "mission"
  ],
  "title": "create_orgArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "create_orgOutput",
  "type": "object"
}
other: {}
description:
Create the organization this server is bound to (only possible while none exists).

        mission: what the organization is for, in a few sentences. default_model: kiro model for all agents
        (optional; unset = claude-sonnet-5.5). path: absolute directory; only needed (and only accepted) when the server is not bound to
        one by ORG_ROOT. The directory must be missing or empty. Afterwards every tool works, no restart needed.
        

### tool: start
input: {
  "properties": {
    "max_runs": {
      "anyOf": [
        {
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Max Runs"
    },
    "until_done": {
      "default": true,
      "title": "Until Done",
      "type": "boolean"
    }
  },
  "title": "startArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "startOutput",
  "type": "object"
}
other: {}
description:
Start the scheduler for this organization in the background; it wakes agents that have mail.

        max_runs: stop starting agent runs after this many (safety cap; default: no cap). until_done (default True):
        the scheduler exits by itself when you have no open task and nothing is running or can run, so you need not
        stop it (status and progress then say "scheduler: stopped (finished: no open tasks)"); start it again after
        giving the org more work. It also exits by itself, after a few minutes (`until_done_grace_seconds`), when every
        open task is waiting for YOU (an agent is out of budget or keeps failing, or a task is stalled): status and
        progress then say "stopped (waiting on you: ...)" with your options. start() refuses while that is the case:
        grant runs first (send(to=<agent>, body=<why>, budget=N)). False keeps it running until stop(). Refused if one
        is already running. Output goes to .runtime/scheduler.log. Returns the scheduler's pid.
        

### tool: stop
input: {
  "properties": {},
  "title": "stopArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "stopOutput",
  "type": "object"
}
other: {}
description:
Stop this organization's scheduler (SIGTERM, then wait briefly). Runs in flight are interrupted and
        redelivered on the next start. Only signals a process verified to be this organization's scheduler.

### tool: blueprint_example
input: {
  "properties": {
    "kind": {
      "default": "research",
      "title": "Kind",
      "type": "string"
    },
    "service": {
      "default": false,
      "title": "Service",
      "type": "boolean"
    }
  },
  "title": "blueprint_exampleArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "blueprint_exampleOutput",
  "type": "object"
}
other: {}
description:
A ready-to-edit blueprint (YAML with a comment on every field and a one-paragraph schema summary).

        kind: "research" (facts from the web with source URLs, fact-checked), "documents" (write from the user's local
        files, no web; uses `needs.inputs`, read-only folders), "code" (software in a repo workspace, with tests and
        local commits) or "analysis" (the user's data files, read-only, analysed by a checked script). Replace every
        <PLACEHOLDER> with what the user told you (ask for what is missing; do not invent lists), delete what does not apply, then call propose_org with the text. Read-only.

        service: true for work the user wants again and again ("every week", "whenever I..."): the template then offers it
        as a standing service (`services:` with inputs, acceptance, deliverable and budget per request, and an optional
        first request) instead of a one-off `task:`.
        

### tool: propose_org
input: {
  "properties": {
    "blueprint": {
      "title": "Blueprint",
      "type": "string"
    }
  },
  "required": [
    "blueprint"
  ],
  "title": "propose_orgArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "propose_orgOutput",
  "type": "object"
}
other: {}
description:
Validate a blueprint and return the plan the user must approve. Writes nothing; safe to call repeatedly.

        blueprint: YAML or JSON text (never a file path). Start from blueprint_example(kind) for a template with every
        field explained. Schema: `mission` (one paragraph); `needs` {scope, deliverable {description, format,
        max_words, path (absolute)}, quality_bar, sources, inputs (read-only folders), workspace (the one absolute
        folder agents may write in), budget_runs (the user's cap), models {cheap, strong} (optional: none = every agent on claude-sonnet-5.5), model_policy, review
        (true/false), approval, progress, kind (research|writing|code), code {tests, packaging, commits}}; `agents`:
        ONE top-level agent (template manager) with `children`; each agent has name and a template (manager,
        researcher, writer, reviewer, fact-checker, engineer, tester, code-reviewer, analyst, data-checker) or a charter, and optionally
        model, tools, workspace, scale; `task` {to, title, goal, acceptance: list of exact, checkable criteria}; optional
        `services` (recurring work the top agent offers on request): [{name, description, inputs: [{name, description,
        required}], acceptance, deliverable {description, format, max_words, path}, budget (runs per request), playbook,
        locked}], in which case `task` may be omitted or be a first request {service, inputs: {name: value}, title}.
        Works before the organization exists. Returns (1) a block headed "PLAN FOR YOU": show it to the user exactly
        as written and wait for their explicit approval; (2) Details, the full plan for you; (3) a plan_id that
        apply_org requires. If the plan has errors, fix the blueprint and propose again; never ask the user to approve
        a plan with errors.
        

### tool: apply_org
input: {
  "properties": {
    "blueprint": {
      "title": "Blueprint",
      "type": "string"
    },
    "approved": {
      "default": false,
      "title": "Approved",
      "type": "boolean"
    },
    "plan_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Plan Id"
    }
  },
  "required": [
    "blueprint"
  ],
  "title": "apply_orgArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "apply_orgOutput",
  "type": "object"
}
other: {}
description:
Create the agents of a blueprint and give its first task. Only after the user approved the plan.

        blueprint: the YAML/JSON text the user approved via propose_org (unchanged). approved: pass True only after
        the user explicitly approved that plan in this conversation; otherwise nothing happens. plan_id: the id that
        propose_org returned for exactly this blueprint; a missing or different id is refused (propose again, show the
        PLAN FOR YOU block, get approval). Needs an existing organization (create_org first if there is none).
        Refuses with the issues if the blueprint has errors or a name is taken, and undoes everything if it fails
        midway. Returns what was created (agents, services, the first task or request); then call start() (not when
        the blueprint gave no first task: the services wait for request(service, inputs)).
        

### tool: progress
input: {
  "properties": {
    "task_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Task Id"
    },
    "wait_seconds": {
      "default": 0,
      "title": "Wait Seconds",
      "type": "integer"
    }
  },
  "title": "progressArguments",
  "type": "object"
}
output: {
  "properties": {
    "result": {
      "title": "Result",
      "type": "string"
    }
  },
  "required": [
    "result"
  ],
  "title": "progressOutput",
  "type": "object"
}
other: {}
description:
One plain status line per task you (root) gave, then what needs your decision, then the scheduler. Read-only.

        Per task: working / waiting on <agent> / stalled / blocked: <reason> / done / failed, who is busy, runs used
        of the budget given (all runs of the task's team since it was given, against its budget plus every later grant),
        time since the last activity, and for finished tasks the artifact paths and the runs returned. "Needs you"
        lists every unread note, escalation, budget request, blocked/failed result and runtime notice, with its id.
        task_id: only that task, in any state (default: open tasks and those finished in the last day).
        wait_seconds (0-900, default 0): first wait until a task finishes, fails, blocks or stalls, or something new
        needs the user, or the time is up, then answer; the answer starts with what changed. A task counts as in
        progress, so the wait really waits, while its state is working/waiting, and also while it is blocked or
        stalled but an agent below it is running or can run (unread mail that wakes it, budget left): for example the
        lead of a blocked task right after you granted it runs and called start. It answers at once only when nothing
        in the org can run, and ends early when the last thing that could run stops. Use it when the user wants to be
        told when the work is done: tell them you will wait now, call progress(wait_seconds=...) and repeat as long
        as they want (a turn cannot notify them later). Never poll with shell sleeps. Without wait_seconds it answers
        "status?".
        
