Skip to main content
Glama

hand_over

Hand a specced project to your crew: record every repo it spans, who handed it over and to which crew, so the orchestrator picks it up on its next tick.

Instructions

Hand a specced project to the crew: Tares records it with every repo it spans, who handed it over and to which crew, and the orchestrator picks it up from Tares on its next tick. repos is one {path, name} per repo: path the absolute folder it is checked out in on this machine, name its GitHub repo (owner/name), the repo that holds the plan first. A later call adds repos, never replaces them. A folder is kept for your crew only: a teammate's crew building the same project hands over its own clone's folder with the same name. autonomy only when the person wants this project stricter than the crew (L3-review: every merge waits for their yes). repo (one path) is the older form. Then send your own crew's orchestrator (the reply names it) a [TF:SHIP] message with SendMessage so it starts now rather than on its tick. If your crew is not running (the reply says so), tell the person to run tares factory crew up first. Other people's crews pick up their own tickets on their next tick. Needs a key with a person. A project kept for later (set_later) starts with it.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "hand_over"
  }
}

Input Schema

NameRequiredDescriptionDefault
repoNo
reposNo
projectNo
autonomyNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.57.0

TDQS

A4.1/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses that Tares persists the handover, that a later call adds repos and never replaces them, that an existing folder stays scoped to your own crew, and that the hander must additionally send a `[TF:SHIP]` message with SendMessage to start the orchestrator immediately. It also names the auth prerequisite (a key with a person) and the failure path when the crew is down.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and most sentences carry real information, but the text is a dense run-on with mid-sentence line breaks and interleaved operational instructions (SendMessage, crew up) that make it hard to scan. It could be restructured into distinct blocks for parameters, side effects, and follow-up steps without losing content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return values needn't be spelled out, and the description still usefully refers to the reply naming the orchestrator crew. For a four-parameter mutation with no annotations, the coverage of side effects, follow-up messaging, and auth is strong; only the `project` parameter's meaning remains unaddressed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate: it documents `repos` as one {path, name} per repo, defines `path` as the absolute checkout folder and `name` as the GitHub owner/name with the plan-holding repo first, explains `autonomy` (L3-review: every merge waits for their yes), and marks `repo` as the older single-path form. Only `project` is left unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("Hand a specced project to the crew") and immediately explains the mechanism: Tares records it with repos, hander, and crew, and the orchestrator picks it up on its next tick. It also explicitly separates itself from set_later ("A project kept for later (set_later) starts with it"), but does not distinguish itself from the sibling hand_project_to_crew, which sounds nearly identical.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives a clear prerequisite ("Needs a key with a person"), a fallback when the crew is not running (tell the person to run `tares factory crew up`), and a condition for autonomy ("only when the person wants this project stricter than the crew"). It gives no explicit when-not-to-use case and never contrasts with hand_project_to_crew.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.