sandhi.naklitechie.com

{
  "name": "sandhi.status",
  "kind": "answer",
  "impl": "imperative",
  "description": "One read of the whole situation: title, counts, check counts by class, closest arc, unsaved state, undo depth, last call. Start here.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.get",
  "kind": "act",
  "impl": "imperative",
  "description": "The full story as JSON (schema sandhi:1): beats, threads, notes. The only read that grows with the story.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.update",
  "kind": "act",
  "impl": "imperative",
  "description": "Set the title, logline, belief, or per-principle notes (\"In this story\"). An empty note removes it. Undo reverses it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string"
      },
      "logline": {
        "type": "string"
      },
      "belief": {
        "type": "string"
      },
      "notes": {
        "type": "object",
        "additionalProperties": {
          "type": "string"
        }
      }
    }
  }
}

{
  "name": "sandhi.story.new",
  "kind": "act",
  "impl": "imperative",
  "description": "Replace the story with a blank Story Spine of five beats. Undo brings the old story back.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.start",
  "kind": "act",
  "impl": "imperative",
  "description": "Start a new story from Story Spine lines, in order: lines [{stage, text}] with stage once, everyday, oneday, because, until or since; plus title, logline and belief. The stage words set the joints (one day: but; because of that, until finally, ever since then: therefore). The New-story wizard calls this. Undo brings the old story back.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string"
      },
      "logline": {
        "type": "string"
      },
      "belief": {
        "type": "string"
      },
      "lines": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "stage": {
              "enum": [
                "once",
                "everyday",
                "oneday",
                "because",
                "until",
                "since"
              ]
            },
            "text": {
              "type": "string"
            }
          },
          "required": [
            "stage"
          ]
        }
      }
    }
  }
}

{
  "name": "sandhi.story.demo",
  "kind": "act",
  "impl": "imperative",
  "description": "Replace the story with \"The whistle\", the ten-beat demo from the explainer. Undo brings the old story back.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.load",
  "kind": "act",
  "impl": "imperative",
  "description": "Replace the story with the given JSON (schema sandhi:1). It is validated first; on failure the story is unchanged. Undo reverses it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "story": {
        "type": "object"
      }
    },
    "required": [
      "story"
    ]
  }
}

{
  "name": "sandhi.story.save",
  "kind": "act",
  "impl": "imperative",
  "description": "Download the story as <title>.sandhi.json. Nothing is uploaded.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.recent",
  "kind": "act",
  "impl": "imperative",
  "description": "The last three stories a replace pushed aside (newest first): k, title, when, beat count. Pass k to get that story in full; story.load brings it back (undoable).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "k": {
        "type": "integer",
        "minimum": 0,
        "maximum": 2
      }
    }
  }
}

{
  "name": "sandhi.story.paste",
  "kind": "act",
  "impl": "imperative",
  "description": "Replace the story with pasted prose, one beat per paragraph, every label left to the writer. No model, nothing guessed. Undo brings the old story back.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      }
    },
    "required": [
      "text"
    ]
  }
}

{
  "name": "sandhi.beat.add",
  "kind": "act",
  "impl": "imperative",
  "description": "Insert a beat after the beat with id `after` (default: at the end). Returns the new id and position.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "after": {
        "type": "string"
      },
      "spine": {
        "enum": [
          "once",
          "everyday",
          "oneday",
          "because",
          "until",
          "since"
        ]
      },
      "label": {
        "type": "string"
      },
      "text": {
        "type": "string"
      },
      "fortune": {
        "type": "integer",
        "minimum": -5,
        "maximum": 5
      },
      "joint": {
        "enum": [
          "therefore",
          "but",
          "and-then",
          null
        ]
      }
    }
  }
}

{
  "name": "sandhi.beat.update",
  "kind": "act",
  "impl": "imperative",
  "description": "Change fields of one beat: label, spine, joint (into this beat), text, fortune, tags, marks, driver, avastha, kis, drafts. Arrays replace whole. Undo reverses it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "patch": {
        "type": "object",
        "properties": {
          "label": {
            "type": "string"
          },
          "spine": {
            "enum": [
              "once",
              "everyday",
              "oneday",
              "because",
              "until",
              "since"
            ]
          },
          "joint": {
            "enum": [
              "therefore",
              "but",
              "and-then",
              null
            ]
          },
          "text": {
            "type": "string"
          },
          "fortune": {
            "type": "integer",
            "minimum": -5,
            "maximum": 5
          },
          "tags": {
            "type": "array",
            "items": {
              "enum": [
                "care",
                "want",
                "stakes",
                "cause",
                "plant",
                "two",
                "surprise",
                "earn",
                "change",
                "cut",
                "ride",
                "why",
                "finish"
              ]
            }
          },
          "marks": {
            "type": "array",
            "items": {
              "enum": [
                "turn",
                "low"
              ]
            }
          },
          "driver": {
            "enum": [
              "luck",
              "choice",
              null
            ]
          },
          "avastha": {
            "enum": [
              "arambha",
              "prayatna",
              "praptyasha",
              "niyatapti",
              "phalagama",
              null
            ]
          },
          "kis": {
            "enum": [
              "ki",
              "sho",
              "ten",
              "ketsu",
              null
            ]
          },
          "drafts": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "n": {
                  "type": "integer"
                },
                "text": {
                  "type": "string"
                },
                "note": {
                  "type": "string"
                }
              }
            }
          }
        }
      }
    },
    "required": [
      "id",
      "patch"
    ]
  }
}

{
  "name": "sandhi.beat.remove",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove a beat. Threads that point at it lose that plant or payoff, and tidbits placed there are unplaced. Undo restores them.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "sandhi.beat.move",
  "kind": "act",
  "impl": "imperative",
  "description": "Move a beat to a 1-based position.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "position": {
        "type": "integer",
        "minimum": 1
      }
    },
    "required": [
      "id",
      "position"
    ]
  }
}

{
  "name": "sandhi.tidbit.add",
  "kind": "act",
  "impl": "imperative",
  "description": "Keep a tidbit: a real-life observation that could give the story life (a curious train stop; meat kept too long gets freezer burn). It waits unplaced until the writer weaves it into beats. Undo removes it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "note": {
        "type": "string"
      },
      "placed": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "text"
    ]
  }
}

{
  "name": "sandhi.tidbit.update",
  "kind": "act",
  "impl": "imperative",
  "description": "Change a tidbit's text, note, or the beats it is placed in (placed replaces whole; [] unplaces it).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "patch": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string"
          },
          "note": {
            "type": "string"
          },
          "placed": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      }
    },
    "required": [
      "id",
      "patch"
    ]
  }
}

{
  "name": "sandhi.tidbit.remove",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove a tidbit. Undo restores it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "sandhi.thread.add",
  "kind": "act",
  "impl": "imperative",
  "description": "Add a plant-and-payoff thread (Chekhov's gun, the bīja): a label, the beat that plants it, the beats that pay it off.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "label": {
        "type": "string"
      },
      "plant": {
        "type": [
          "string",
          "null"
        ]
      },
      "payoffs": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "label"
    ]
  }
}

{
  "name": "sandhi.thread.update",
  "kind": "act",
  "impl": "imperative",
  "description": "Change a thread's label, plant beat, payoff beats (payoffs replace whole), or open: true to leave it open on purpose (a planted thread with no payoff is then not flagged).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "patch": {
        "type": "object",
        "properties": {
          "label": {
            "type": "string"
          },
          "plant": {
            "type": [
              "string",
              "null"
            ]
          },
          "payoffs": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "open": {
            "type": "boolean"
          }
        }
      }
    },
    "required": [
      "id",
      "patch"
    ]
  }
}

{
  "name": "sandhi.thread.remove",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove a thread. Undo restores it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "sandhi.checks",
  "kind": "answer",
  "impl": "imperative",
  "description": "The checks on the current labels (SPEC §2): each with class, beat position, message and the next step. A clean story returns count 0.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.arc",
  "kind": "act",
  "impl": "imperative",
  "description": "Pearson fit of the fortune line against the six arcs (Reagan et al. 2016); best shape and every score.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.coverage",
  "kind": "act",
  "impl": "imperative",
  "description": "For each of the 13 principles, the beat positions tagged with it.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.view.focus",
  "kind": "act",
  "impl": "imperative",
  "description": "Focus the page on one principle (dims other beats, opens its panel), or \"all\" to clear.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "principle": {
        "enum": [
          "all",
          "care",
          "want",
          "stakes",
          "cause",
          "plant",
          "two",
          "surprise",
          "earn",
          "change",
          "cut",
          "ride",
          "why",
          "finish"
        ]
      }
    },
    "required": [
      "principle"
    ]
  }
}

{
  "name": "sandhi.undo",
  "kind": "act",
  "impl": "imperative",
  "description": "Undo the last story change (100 steps).",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.redo",
  "kind": "act",
  "impl": "imperative",
  "description": "Redo the last undone change.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.journal",
  "kind": "act",
  "impl": "imperative",
  "description": "The last n tool calls (default 20, max 200): tool, class, door, ms, time. The trajectory across sessions.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "n": {
        "type": "integer",
        "minimum": 1,
        "maximum": 200
      }
    }
  }
}

{
  "name": "sandhi.reader.status",
  "kind": "answer",
  "impl": "imperative",
  "description": "The AI ladder, closest first: a model server on this machine, Gemini Nano in Chrome, your provider with your key. Which rungs can read, the chosen rung and where its words go, the provider and model, key fingerprints (never keys). probe: true also looks for a local server (Chrome may ask to allow local network access).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "probe": {
        "type": "boolean"
      }
    }
  }
}

{
  "name": "sandhi.reader.select",
  "kind": "act",
  "impl": "imperative",
  "description": "Choose the rung (\"machine\", \"device\", \"provider\"), the provider (openrouter, openai, anthropic, gemini, groq, mistral, deepseek, together, custom), the local server, and the model id for the chosen rung. A custom address is set with its key, by the writer (reader.key).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "rung": {
        "enum": [
          "machine",
          "device",
          "provider"
        ]
      },
      "provider": {
        "enum": [
          "openrouter",
          "openai",
          "anthropic",
          "gemini",
          "groq",
          "mistral",
          "deepseek",
          "together",
          "custom"
        ]
      },
      "server": {
        "enum": [
          "ollama",
          "lmstudio"
        ]
      },
      "model": {
        "type": "string"
      }
    }
  }
}

{
  "name": "sandhi.reader.models",
  "kind": "act",
  "impl": "imperative",
  "description": "The model ids the chosen rung offers: a local server's list, or your provider's list fetched with your key.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.chapter.start",
  "kind": "act",
  "impl": "imperative",
  "description": "Start a chapter at a beat: the name goes on that beat and on the beats after it, up to the next beat that already starts or belongs to another chapter. An empty name ends the chapter there (the same beats lose their name). Undo reverses it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "beat": {
        "type": "string"
      },
      "name": {
        "type": "string"
      }
    },
    "required": [
      "beat",
      "name"
    ]
  }
}

{
  "name": "sandhi.learn.get",
  "kind": "answer",
  "impl": "imperative",
  "description": "How stories work: the 13 principles (line, what each source says and who pushes back, the beats of this story that serve it), the six fortune shapes, and the sources. principle narrows it to one.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "principle": {
        "type": "string"
      }
    }
  }
}

{
  "name": "sandhi.write.questions",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader 2 to 4 questions about one beat, each from a principle the beat does least for. Questions only; nothing enters the story. The result replaces any earlier suggestion (write.get). It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "beat": {
        "type": "string",
        "description": "beat id"
      }
    },
    "required": [
      "beat"
    ]
  }
}

{
  "name": "sandhi.write.options",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader what could happen at one beat: the obvious option, named and set aside, then 3 to 5 others, each one line with its joint, fortune, principle and why; at least one where things get worse. Proposals only: nothing enters the story, and there is no tool that writes an option into a beat; the writer writes. It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "beat": {
        "type": "string",
        "description": "beat id"
      }
    },
    "required": [
      "beat"
    ]
  }
}

{
  "name": "sandhi.write.joints",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader to judge every joint the writer labelled therefore or but: holds, slack (and then fits better) or unsure, with a reason and a question. Advice only; no joint is relabelled. It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.write.shape",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader how to bring the beats that sit 2 or more from the writer's sketched fortune line toward it: one line per beat, with why. Proposals only; no fortune or text changes. Needs a sketch (story.sketch). It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.write.interview",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader for one question aimed at the weakest place in the story (empty beats, the checks, thin beats, principles no beat serves), with where the answer belongs: a beat's text, a tidbit or a note. The writer answers in their own words (beat.update, tidbit.add, story.update); nothing is written by the model. It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.write.depth",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader how to give one thin beat depth: 2 to 4 suggestions, each a tidbit to look for or use, a plant, or a question, never prose. Nothing enters the story. It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "beat": {
        "type": "string",
        "description": "beat id"
      }
    },
    "required": [
      "beat"
    ]
  }
}

{
  "name": "sandhi.write.plot",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader how the structure changes around a new plot element: up to 6 changes, each a new empty beat (its stage, joint, fortune and a one-line label) or a relabel of an existing beat's stage, joint or fortune, with why. A proposal with a diff (write.get); nothing changes until the writer applies it (write.apply, person-only). It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "element": {
        "type": "string",
        "description": "the plot element, in a line"
      }
    },
    "required": [
      "element"
    ]
  }
}

{
  "name": "sandhi.write.place",
  "kind": "act",
  "impl": "imperative",
  "description": "Ask the chosen reader where each unplaced tidbit fits: a beat, whether it lives there as action, character or setting, how in one line, and why. Proposals only; placing one is tidbit.update {placed}. It uses the reader the writer chose.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.story.sketch",
  "kind": "act",
  "impl": "imperative",
  "description": "Set the shape the writer wants the fortune to follow: points [{t, v}] with t from 0 (the first beat) to 1 (the last) and v from -5 to 5, resampled to 25 values; an empty list clears it. The chart draws it under the fortune line and rings beats 2 or more from it. Undo reverses it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "points": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "t": {
              "type": "number"
            },
            "v": {
              "type": "number"
            }
          },
          "required": [
            "t",
            "v"
          ]
        }
      }
    },
    "required": [
      "points"
    ]
  }
}

{
  "name": "sandhi.write.get",
  "kind": "answer",
  "impl": "imperative",
  "description": "The current suggestion (questions, options or joint verdicts), or no_proposal.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.write.dismiss",
  "kind": "act",
  "impl": "imperative",
  "description": "Drop the current suggestion. Nothing was kept from it.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.read.run",
  "kind": "act",
  "impl": "imperative",
  "description": "Read a story (prose) with the chosen rung and stage a proposed structure; the story does not change. Beats are the writer's own text cut at the model's exact quotes; quotes not found in the text are dropped. Long stories are read in parts, then as a whole outline; a manuscript with chapter headings is read a chapter at a time, one beat per chapter, and resumes where it stopped (report: chapters, resumed); Gemini Nano cannot read in parts and refuses them (too_long) before any model call. strategy: \"whole\" (one call reads and labels) or \"split\" (one call finds the beats, a second labels them). Spends: on the provider rung the story goes to the writer's provider, billed to the writer, so an agent may use that rung only when the writer chose it.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "rung": {
        "enum": [
          "machine",
          "device",
          "provider"
        ]
      },
      "strategy": {
        "enum": [
          "whole",
          "split"
        ]
      }
    },
    "required": [
      "text"
    ]
  }
}

{
  "name": "sandhi.read.paragraphs",
  "kind": "act",
  "impl": "imperative",
  "description": "Stage prose split one beat per paragraph, with no model and every label left to the writer, as a proposal like a read (read.get shows it; the writer accepts it in the page). The story does not change.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      }
    },
    "required": [
      "text"
    ]
  }
}

{
  "name": "sandhi.read.get",
  "kind": "act",
  "impl": "imperative",
  "description": "The staged proposal: the proposed story (schema sandhi:1) and the read report.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.read.cancel",
  "kind": "transact",
  "impl": "imperative",
  "description": "Stop the read that is running. Its model call is aborted; nothing is staged.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "sandhi.read.discard",
  "kind": "act",
  "impl": "imperative",
  "description": "Drop the staged proposal. The story is unchanged; the proposal cannot be brought back.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}