Tool tree
gradeNot graded
get-stateAnswer
Returns everything the page shows a visitor right now: the growth total and the rate it is climbing at (in growth per second), the growth the garden has produced over its whole life (lifetimeGrowth — it is never spent, so it survives planting a seed or opening a bed and keeps climbing across a replant), and what replanting right now would earn from that lifetime as a lasting bonus (replantBonus — sublinear in the lifetime, so going further in one run is worth more than replanting early), whether the garden is far enough along to be replanted at all (canReplant — false below the bed-of-seedlings wall, so a replant is only ever offered once the garden is flourishing), and the lasting bonus a replant has already earned (bonus — in growth per second, added flat to the rate the garden grows at, 0 before the first replant), and what the garden's lifetime has made of the ground, the lasting layer the plot draws under its current growth and a replant never resets (established: the ground's name and its index among the tiers, the lifetime it began at (at) and the next tier's threshold (nextAt), and how far through the tier the lifetime is as a 0-to-1 fraction (fill) — fresh ground at 0 is a garden that has never produced), the season the garden's age falls in (season: its key, name, growth multiplier and the pollinator rhythm the season gives — pollinatorCycleSeconds and pollinatorBaseVisitSeconds — the cycle repeats on its own, no season grows slower than the base rate, and the season readout names the kind the year is favouring now, if any), the pollinator's visit (pollinator: visiting, its multiplier, how long the visit lasts in seconds (visitSeconds), the season it is following (seasonKey), how often that season brings it (cycleSeconds), the visit a garden with no blooms keeps in its season (baseVisitSeconds), the longest a visit can stretch (maxVisitSeconds), and how many grown blooms are lengthening it (bloomsKeeping) — each bloom adds seconds to the visit up to a cap and the season sets the cycle and the base visit, so a bed of blooms keeps the x2 boost on the plot for most of the season's cycle), the garden form the plot is drawing (its name and its index among the forms, lowest first), the next named form it is growing toward (nextFormName, null past the last form), how much growth still separates the garden from it (growthToNextForm), and how full that stretch is as a 0-to-1 fraction (formProgress), the ungrown seeds sprouting in the soil, the grown plants, the total planted (totalPlanted), how many beds of soil the garden owns (beds), how many plots those beds make (capacity = beds times the plots per bed), the growing time a seed takes (growSeconds), the seconds until the next seed matures into a plant (secondsToNextPlant, null when no seed is growing), the portable save string, whether this browser is keeping the garden, and whether a load can still be put back (restoreAvailable — true only while a garden a load replaced is kept, which restore-save spends and another load replaces). It reports the two kinds of seed a visitor can plant as `kinds`, herb first: each entry carries the kind's name (key), the price of its next seed (cost), how much one grown plant adds to the growth rate before milestones (production) and what it actually earns now (output — production lifted by the milestones that kind has reached), how long its sprouts take (growSeconds), the season it thrives in (bestSeason) and its own growth boost right now (seasonMultiplier — its seasonBoost in its best season and 1 the rest of the year), how many of its seeds are ungrown and how many plants are grown, and whether the garden can afford it now (canPlant). Each kind also has a small ladder of plant-count milestones, shown at different counts for each kind: reaching one immediately multiplies that kind's output, so the boost is derived from the grown-plant counts alone and survives a reload or a return with no save change. The entry carries the multiplier its plant count has earned (milestoneMultiplier), the next milestone it is reaching for (nextMilestone, null once its ladder is climbed) and how many more plants of that kind it needs (plantsToMilestone, null beside a null nextMilestone), so the caller can say which seed is worth planting next. It also returns the seed the garden can plant right now (nextSeedKind) and what it costs (nextSeedCost), whether the garden can afford it now (canPlantSeed), whether the plot is full (plotFull), how far along the cost the garden is as a 0-to-1 fraction (seedCostProgress), and the seconds until it can afford it (secondsToNextSeed, null when full or not growing) — these are the seed the Plant controls and the goal-reached announcement read, so they name what the garden can do now rather than the target still ahead, which is `goal` below. The one target the goal line is reaching for is returned as goal: always a thing the garden has NOT reached, so its meter is never already full and it never reads ready — the nearest seed the free soil cannot yet afford (kind "seed", key and name the kind), then the next bed once every plot is full (kind "bed", name "bed #N"), then the next form (kind "form", name the form, e.g. "a grove"). It carries the target's cost, how much growth is still needed to reach it (growthToGo), how full the stretch to it is as a 0-to-1 fraction (progress, the meter the page draws), and the estimated seconds until the garden can afford it (secondsToGo, null when nothing is growing). The goal title and the three labelled facts on the page name this same target and state this same distance. Once every plot is full it also returns the next bed: what opening it costs (nextBedCost), whether the garden can afford it now (canOpenBed — only ever true on a full plot), how far along that cost it is as a 0-to-1 fraction (bedCostProgress), and the seconds until it can afford it (secondsToNextBed, null unless the plot is full and the garden is growing). It also reports away: the time since the visitor was last here and what it grew — seconds (0 on a first visit or a quick reload), earned growth, how many seeds it sowed into the free plots while away (sown) and what those seeds cost out of the growth (sownCost), how many seeds matured (matured), the form it started at (from) and reached (to), the formsFound on the way, a plain summary sentence, and the same facts the page shows as short labelled values (facts, each {label, value}) — the last of those facts is the next goal, and it is read from the garden growing now rather than frozen at the moment of returning, so the distance it states is the same number the page's garden-form row states and moves as the garden keeps growing; every other fact is the absence's own record and never changes while the return is shown. It also reports returnMarks: what the last return marked on the plot and the readout — how many plants matured (plants), how many seeds the garden sowed into the free plots while away (sown) and the plots it points out, whether a new form was reached (form), and the season turn (season: {from, to}, the season the garden turned from and into, present when the absence crossed a boundary even with no seed matured and no new form), or null once the marks clear. A first visit or a quick reload marks nothing, and the marks never clear on a timer: they stay until the visitor acknowledges the return, which tend, plant-seed, open-bed, replant, import-save or dismiss-return all do. It also reports visit: the garden's hand-work since it was last replanted, kept apart from the seeds the garden sows itself and the plants that matured while away — how long the record has run in seconds (seconds), and how many plots were sowed (sown) and tended (tended) by hand. The three start at zero, rise only when the visitor acts (the garden's own growth and its away-sown seeds never change them), survive a reload and a return, and are cleared only by a replant. Whether someone is at the page right now is reported as visitPresent — true while the page is open and visible, false while it is hidden, so a garden with a visitor at it is told apart from one growing alone. It is the same presence the plot draws as worked ground and standing plants, and it is not a saved field. What that presence earns the garden is reported as presenceRate — the extra growth per second added while someone is at the page, a flat amount added to the rate the garden already grows at, so the garden grows at rate + presenceRate while it is watched and at rate alone while it is not. It is the fixed amount the readout names beside the rate while the visit lasts and 0 the moment the visit ends, so two minutes watched end larger than the same garden left alone and an absence is never punished. It also reports sandbox: the time rehearsal when one is open — how many seconds it has been wound forward and a readable elapsed label, the growth, form, ungrown seeds and grown plants it reached, how many beds of soil it holds and how many plots those beds make (beds, capacity), whether a pollinator is visiting and the boost it brings (pollinator) and each kind's seeds, plants and next-seed price (kinds, the two of them in the same shape the garden's own kinds carry), how many seeds matured (matured), the return summary the real garden would show and the same facts as short labelled values (facts), and the next goal it would offer (goalTitle, goalDetail) — or {open: false} when no sandbox is open. The sandbox carries the garden's own controls too: act-in-sandbox can tend, plant-herb, plant-bloom and open-bed inside the rehearsal copy, and the sandbox's status string says what the last one did. Rehearsing never touches the real garden. Ask it before acting so you know what the visitor sees.
View tool JSON
{
"name": "get-state",
"kind": "answer",
"impl": "imperative",
"description": "Returns everything the page shows a visitor right now: the growth total and the rate it is climbing at (in growth per second), the growth the garden has produced over its whole life (lifetimeGrowth — it is never spent, so it survives planting a seed or opening a bed and keeps climbing across a replant), and what replanting right now would earn from that lifetime as a lasting bonus (replantBonus — sublinear in the lifetime, so going further in one run is worth more than replanting early), whether the garden is far enough along to be replanted at all (canReplant — false below the bed-of-seedlings wall, so a replant is only ever offered once the garden is flourishing), and the lasting bonus a replant has already earned (bonus — in growth per second, added flat to the rate the garden grows at, 0 before the first replant), and what the garden's lifetime has made of the ground, the lasting layer the plot draws under its current growth and a replant never resets (established: the ground's name and its index among the tiers, the lifetime it began at (at) and the next tier's threshold (nextAt), and how far through the tier the lifetime is as a 0-to-1 fraction (fill) — fresh ground at 0 is a garden that has never produced), the season the garden's age falls in (season: its key, name, growth multiplier and the pollinator rhythm the season gives — pollinatorCycleSeconds and pollinatorBaseVisitSeconds — the cycle repeats on its own, no season grows slower than the base rate, and the season readout names the kind the year is favouring now, if any), the pollinator's visit (pollinator: visiting, its multiplier, how long the visit lasts in seconds (visitSeconds), the season it is following (seasonKey), how often that season brings it (cycleSeconds), the visit a garden with no blooms keeps in its season (baseVisitSeconds), the longest a visit can stretch (maxVisitSeconds), and how many grown blooms are lengthening it (bloomsKeeping) — each bloom adds seconds to the visit up to a cap and the season sets the cycle and the base visit, so a bed of blooms keeps the x2 boost on the plot for most of the season's cycle), the garden form the plot is drawing (its name and its index among the forms, lowest first), the next named form it is growing toward (nextFormName, null past the last form), how much growth still separates the garden from it (growthToNextForm), and how full that stretch is as a 0-to-1 fraction (formProgress), the ungrown seeds sprouting in the soil, the grown plants, the total planted (totalPlanted), how many beds of soil the garden owns (beds), how many plots those beds make (capacity = beds times the plots per bed), the growing time a seed takes (growSeconds), the seconds until the next seed matures into a plant (secondsToNextPlant, null when no seed is growing), the portable save string, whether this browser is keeping the garden, and whether a load can still be put back (restoreAvailable — true only while a garden a load replaced is kept, which restore-save spends and another load replaces). It reports the two kinds of seed a visitor can plant as `kinds`, herb first: each entry carries the kind's name (key), the price of its next seed (cost), how much one grown plant adds to the growth rate before milestones (production) and what it actually earns now (output — production lifted by the milestones that kind has reached), how long its sprouts take (growSeconds), the season it thrives in (bestSeason) and its own growth boost right now (seasonMultiplier — its seasonBoost in its best season and 1 the rest of the year), how many of its seeds are ungrown and how many plants are grown, and whether the garden can afford it now (canPlant). Each kind also has a small ladder of plant-count milestones, shown at different counts for each kind: reaching one immediately multiplies that kind's output, so the boost is derived from the grown-plant counts alone and survives a reload or a return with no save change. The entry carries the multiplier its plant count has earned (milestoneMultiplier), the next milestone it is reaching for (nextMilestone, null once its ladder is climbed) and how many more plants of that kind it needs (plantsToMilestone, null beside a null nextMilestone), so the caller can say which seed is worth planting next. It also returns the seed the garden can plant right now (nextSeedKind) and what it costs (nextSeedCost), whether the garden can afford it now (canPlantSeed), whether the plot is full (plotFull), how far along the cost the garden is as a 0-to-1 fraction (seedCostProgress), and the seconds until it can afford it (secondsToNextSeed, null when full or not growing) — these are the seed the Plant controls and the goal-reached announcement read, so they name what the garden can do now rather than the target still ahead, which is `goal` below. The one target the goal line is reaching for is returned as goal: always a thing the garden has NOT reached, so its meter is never already full and it never reads ready — the nearest seed the free soil cannot yet afford (kind \"seed\", key and name the kind), then the next bed once every plot is full (kind \"bed\", name \"bed #N\"), then the next form (kind \"form\", name the form, e.g. \"a grove\"). It carries the target's cost, how much growth is still needed to reach it (growthToGo), how full the stretch to it is as a 0-to-1 fraction (progress, the meter the page draws), and the estimated seconds until the garden can afford it (secondsToGo, null when nothing is growing). The goal title and the three labelled facts on the page name this same target and state this same distance. Once every plot is full it also returns the next bed: what opening it costs (nextBedCost), whether the garden can afford it now (canOpenBed — only ever true on a full plot), how far along that cost it is as a 0-to-1 fraction (bedCostProgress), and the seconds until it can afford it (secondsToNextBed, null unless the plot is full and the garden is growing). It also reports away: the time since the visitor was last here and what it grew — seconds (0 on a first visit or a quick reload), earned growth, how many seeds it sowed into the free plots while away (sown) and what those seeds cost out of the growth (sownCost), how many seeds matured (matured), the form it started at (from) and reached (to), the formsFound on the way, a plain summary sentence, and the same facts the page shows as short labelled values (facts, each {label, value}) — the last of those facts is the next goal, and it is read from the garden growing now rather than frozen at the moment of returning, so the distance it states is the same number the page's garden-form row states and moves as the garden keeps growing; every other fact is the absence's own record and never changes while the return is shown. It also reports returnMarks: what the last return marked on the plot and the readout — how many plants matured (plants), how many seeds the garden sowed into the free plots while away (sown) and the plots it points out, whether a new form was reached (form), and the season turn (season: {from, to}, the season the garden turned from and into, present when the absence crossed a boundary even with no seed matured and no new form), or null once the marks clear. A first visit or a quick reload marks nothing, and the marks never clear on a timer: they stay until the visitor acknowledges the return, which tend, plant-seed, open-bed, replant, import-save or dismiss-return all do. It also reports visit: the garden's hand-work since it was last replanted, kept apart from the seeds the garden sows itself and the plants that matured while away — how long the record has run in seconds (seconds), and how many plots were sowed (sown) and tended (tended) by hand. The three start at zero, rise only when the visitor acts (the garden's own growth and its away-sown seeds never change them), survive a reload and a return, and are cleared only by a replant. Whether someone is at the page right now is reported as visitPresent — true while the page is open and visible, false while it is hidden, so a garden with a visitor at it is told apart from one growing alone. It is the same presence the plot draws as worked ground and standing plants, and it is not a saved field. What that presence earns the garden is reported as presenceRate — the extra growth per second added while someone is at the page, a flat amount added to the rate the garden already grows at, so the garden grows at rate + presenceRate while it is watched and at rate alone while it is not. It is the fixed amount the readout names beside the rate while the visit lasts and 0 the moment the visit ends, so two minutes watched end larger than the same garden left alone and an absence is never punished. It also reports sandbox: the time rehearsal when one is open — how many seconds it has been wound forward and a readable elapsed label, the growth, form, ungrown seeds and grown plants it reached, how many beds of soil it holds and how many plots those beds make (beds, capacity), whether a pollinator is visiting and the boost it brings (pollinator) and each kind's seeds, plants and next-seed price (kinds, the two of them in the same shape the garden's own kinds carry), how many seeds matured (matured), the return summary the real garden would show and the same facts as short labelled values (facts), and the next goal it would offer (goalTitle, goalDetail) — or {open: false} when no sandbox is open. The sandbox carries the garden's own controls too: act-in-sandbox can tend, plant-herb, plant-bloom and open-bed inside the rehearsal copy, and the sandbox's status string says what the last one did. Rehearsing never touches the real garden. Ask it before acting so you know what the visitor sees.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}tendAction
Does what the page's Tend the soil button does: earns the garden's growth now and raises the rate it keeps growing at, so the total climbs on its own afterwards, and hurries the nearest ungrown seed along — get-state's secondsToNextPlant drops by the hurry, so a tended garden reaches its next plant before the same garden left alone. Safe to repeat, each tend adds more; the hurry is bounded, so only the clock can finish a seed. Returns the state afterwards so the caller can see the new total, rate and next-plant distance.
View tool JSON
{
"name": "tend",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Tend the soil button does: earns the garden's growth now and raises the rate it keeps growing at, so the total climbs on its own afterwards, and hurries the nearest ungrown seed along — get-state's secondsToNextPlant drops by the hurry, so a tended garden reaches its next plant before the same garden left alone. Safe to repeat, each tend adds more; the hurry is bounded, so only the clock can finish a seed. Returns the state afterwards so the caller can see the new total, rate and next-plant distance.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}plant-seedAction
Does what the page's Plant a seed buttons do: spends the garden's growth on another seed and puts a sprouting seed in the soil. Give `kind` as "herb" or "bloom" — herb is the cheap, quick seed and bloom costs more, earns more and matures slower; get-state's kinds array reports each kind's cost, production and growing time, and its nextSeedKind names the seed the goal panel is worth reaching for. The sprout speeds nothing up yet — after its growSeconds it matures into a grown plant, and it is the grown plant that raises the rate the garden keeps growing at. The price rises with every seed or plant already in the plot, so get-state's kinds costs are what this will charge. It refuses, changing nothing, when the garden has not saved enough growth or every plot is full — capacity comes from the number of beds the garden owns, so open-bed is how a full plot grows. Returns whether it planted, the kind and cost, the reason when it refused, and the state afterwards.
View tool JSON
{
"name": "plant-seed",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Plant a seed buttons do: spends the garden's growth on another seed and puts a sprouting seed in the soil. Give `kind` as \"herb\" or \"bloom\" — herb is the cheap, quick seed and bloom costs more, earns more and matures slower; get-state's kinds array reports each kind's cost, production and growing time, and its nextSeedKind names the seed the goal panel is worth reaching for. The sprout speeds nothing up yet — after its growSeconds it matures into a grown plant, and it is the grown plant that raises the rate the garden keeps growing at. The price rises with every seed or plant already in the plot, so get-state's kinds costs are what this will charge. It refuses, changing nothing, when the garden has not saved enough growth or every plot is full — capacity comes from the number of beds the garden owns, so open-bed is how a full plot grows. Returns whether it planted, the kind and cost, the reason when it refused, and the state afterwards.",
"inputSchema": {
"type": "object",
"properties": {
"kind": {
"type": "string",
"enum": [
"herb",
"bloom"
],
"description": "Which seed to plant: \"herb\" (default) or \"bloom\"."
}
},
"additionalProperties": false
},
"page": "/selfgrow/"
}open-bedAction
Does what the page's Open the next bed button does: spends the garden's growth on another bed of soil and adds more plots to plant in. It is how a plot that is full keeps growing — get-state's nextBedCost is what this will charge, and its preconditions are a full plot (plotFull) and enough growth (canOpenBed). Opening widens the drawn plot and raises the garden's plots of soil (capacity) by a whole bed. The next bed costs more than the last, so the price climbs. It refuses, changing nothing, when the plot still has room to plant or the garden has not saved enough growth. Returns whether it opened, the cost, how many beds the garden now owns, the reason when it refused, and the state afterwards.
View tool JSON
{
"name": "open-bed",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Open the next bed button does: spends the garden's growth on another bed of soil and adds more plots to plant in. It is how a plot that is full keeps growing — get-state's nextBedCost is what this will charge, and its preconditions are a full plot (plotFull) and enough growth (canOpenBed). Opening widens the drawn plot and raises the garden's plots of soil (capacity) by a whole bed. The next bed costs more than the last, so the price climbs. It refuses, changing nothing, when the plot still has room to plant or the garden has not saved enough growth. Returns whether it opened, the cost, how many beds the garden now owns, the reason when it refused, and the state afterwards.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}replantAction
Does what the page's Replant the garden button does, after the same confirmation, and like loading a save it is deliberately two steps: a replant must be confirmed. A call without confirm: true changes nothing and returns what a replant would reset (the current growth, seeds, plants and beds), what it would keep (the lifetime growth and the lasting bonus already earned), and the bonus it would earn (replantBonus, added flat to the growth rate for every run after), plus needsConfirmation: true and applied: false. Call again with confirm: true to actually replant: it starts a fresh garden — the same soil, one ungrown seed and one bed a first visit has — keeping the lifetime growth and the save and setting that lasting bonus, and the return then carries applied: true, whether it replanted, the bonus it set, the lifetime kept and the state afterwards. get-state's canReplant says whether the garden is far enough along (false below the bed-of-seedlings wall) and what a replant would earn (replantBonus); a replant is only worth it once the fresh garden will pass the old wall faster than the first run did. It refuses, changing nothing at all, when the garden is not yet eligible — declining is exactly a no-op.
View tool JSON
{
"name": "replant",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Replant the garden button does, after the same confirmation, and like loading a save it is deliberately two steps: a replant must be confirmed. A call without confirm: true changes nothing and returns what a replant would reset (the current growth, seeds, plants and beds), what it would keep (the lifetime growth and the lasting bonus already earned), and the bonus it would earn (replantBonus, added flat to the growth rate for every run after), plus needsConfirmation: true and applied: false. Call again with confirm: true to actually replant: it starts a fresh garden — the same soil, one ungrown seed and one bed a first visit has — keeping the lifetime growth and the save and setting that lasting bonus, and the return then carries applied: true, whether it replanted, the bonus it set, the lifetime kept and the state afterwards. get-state's canReplant says whether the garden is far enough along (false below the bed-of-seedlings wall) and what a replant would earn (replantBonus); a replant is only worth it once the fresh garden will pass the old wall faster than the first run did. It refuses, changing nothing at all, when the garden is not yet eligible — declining is exactly a no-op.",
"inputSchema": {
"type": "object",
"properties": {
"confirm": {
"type": "boolean",
"description": "Set true to actually replant. Omitted or false returns the preview and changes nothing."
}
},
"additionalProperties": false
},
"page": "/selfgrow/"
}dismiss-returnAction
Does what the page's Dismiss control beside the New since you left marks does: acknowledges the last return and clears its marks from the plot and the readout, without changing the garden itself. The marks never clear on their own, so use this when a visitor has seen what the absence grew and wants the readout uncluttered; any garden action (tend, plant-seed, open-bed, replant) or import-save clears them too. get-state's returnMarks says whether there is anything to dismiss. Safe to repeat: with nothing marked it changes nothing. Returns the state afterwards, whose returnMarks is null.
View tool JSON
{
"name": "dismiss-return",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Dismiss control beside the New since you left marks does: acknowledges the last return and clears its marks from the plot and the readout, without changing the garden itself. The marks never clear on their own, so use this when a visitor has seen what the absence grew and wants the readout uncluttered; any garden action (tend, plant-seed, open-bed, replant) or import-save clears them too. get-state's returnMarks says whether there is anything to dismiss. Safe to repeat: with nothing marked it changes nothing. Returns the state afterwards, whose returnMarks is null.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}open-sandboxAction
Opens the page's time rehearsal: a copy of the garden kept only in memory and wound forward on demand, so a caller can see what an hour, a day or a month away would grow without risking the real garden. Opening copies the garden as it is now, wound back to its start; opening again re-copies it. Nothing the sandbox does is ever saved, and the real garden, its save and its last-seen moment are left untouched. Use fast-forward-sandbox to wind it forward, reset-sandbox to put it back and close-sandbox to put it away. Returns the state afterwards, whose sandbox field is the rehearsal and whose other fields are the untouched real garden.
View tool JSON
{
"name": "open-sandbox",
"kind": "act",
"impl": "imperative",
"description": "Opens the page's time rehearsal: a copy of the garden kept only in memory and wound forward on demand, so a caller can see what an hour, a day or a month away would grow without risking the real garden. Opening copies the garden as it is now, wound back to its start; opening again re-copies it. Nothing the sandbox does is ever saved, and the real garden, its save and its last-seen moment are left untouched. Use fast-forward-sandbox to wind it forward, reset-sandbox to put it back and close-sandbox to put it away. Returns the state afterwards, whose sandbox field is the rehearsal and whose other fields are the untouched real garden.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}fast-forward-sandboxAction
Winds the sandbox garden forward by one span — an hour, a day or a month — from the snapshot it was opened at, so the result never drifts however many times it is called. It opens the sandbox first if it is closed, copying the real garden as it is now. Rehearsing changes nothing real: the real garden's growth, seeds, plants and save stay exactly as they were. Returns the state afterwards; its sandbox field carries the wound-forward growth, form, ungrown seeds and grown plants, the return summary the real garden would show plus the same facts as short labelled values (facts), and the next goal it would offer.
View tool JSON
{
"name": "fast-forward-sandbox",
"kind": "act",
"impl": "imperative",
"description": "Winds the sandbox garden forward by one span — an hour, a day or a month — from the snapshot it was opened at, so the result never drifts however many times it is called. It opens the sandbox first if it is closed, copying the real garden as it is now. Rehearsing changes nothing real: the real garden's growth, seeds, plants and save stay exactly as they were. Returns the state afterwards; its sandbox field carries the wound-forward growth, form, ungrown seeds and grown plants, the return summary the real garden would show plus the same facts as short labelled values (facts), and the next goal it would offer.",
"inputSchema": {
"type": "object",
"properties": {
"span": {
"type": "string",
"enum": [
"hour",
"day",
"month"
],
"description": "How far to wind the sandbox: \"hour\", \"day\" or \"month\"."
}
},
"required": [
"span"
],
"additionalProperties": false
},
"page": "/selfgrow/"
}act-in-sandboxAction
Does what the page's rehearsal buttons do: runs one of the garden's own actions against the sandbox copy instead of the real garden, so a visitor can try the decisions they would make over an hour or a month away. Give `action` as "tend" (earn growth and raise the rate), "plant-herb" or "plant-bloom" (spend the rehearsal's growth on a seed), or "open-bed" (spend it on another bed once the plot is full). It opens the sandbox first if it is closed, settling any time already wound forward so the action runs at the moment the rehearsal has reached. The rules — cost, capacity and refusals — are the same ones the real tend, plant-seed and open-bed apply, but only the rehearsal changes: the real garden, its save and its last-seen moment stay exactly as they were. Use fast-forward-sandbox to wind the rehearsal forward around the actions, and reset-sandbox to put it back to the moment it opened. Returns whether it took, the action, the reason when it refused, the cost it spent, how many beds the rehearsal now owns, and the whole state afterwards — whose sandbox field is the acted rehearsal beside the untouched real garden.
View tool JSON
{
"name": "act-in-sandbox",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's rehearsal buttons do: runs one of the garden's own actions against the sandbox copy instead of the real garden, so a visitor can try the decisions they would make over an hour or a month away. Give `action` as \"tend\" (earn growth and raise the rate), \"plant-herb\" or \"plant-bloom\" (spend the rehearsal's growth on a seed), or \"open-bed\" (spend it on another bed once the plot is full). It opens the sandbox first if it is closed, settling any time already wound forward so the action runs at the moment the rehearsal has reached. The rules — cost, capacity and refusals — are the same ones the real tend, plant-seed and open-bed apply, but only the rehearsal changes: the real garden, its save and its last-seen moment stay exactly as they were. Use fast-forward-sandbox to wind the rehearsal forward around the actions, and reset-sandbox to put it back to the moment it opened. Returns whether it took, the action, the reason when it refused, the cost it spent, how many beds the rehearsal now owns, and the whole state afterwards — whose sandbox field is the acted rehearsal beside the untouched real garden.",
"inputSchema": {
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": [
"tend",
"plant-herb",
"plant-bloom",
"open-bed"
],
"description": "Which garden action to take inside the rehearsal: tend, plant-herb, plant-bloom or open-bed."
}
},
"required": [
"action"
],
"additionalProperties": false
},
"page": "/selfgrow/"
}reset-sandboxAction
Puts the sandbox garden back to the moment it was opened, undoing every fast-forward. Safe to call when the sandbox is closed: it does nothing then, and the state reports sandbox.open false. Changes nothing real. Returns the state afterwards.
View tool JSON
{
"name": "reset-sandbox",
"kind": "act",
"impl": "imperative",
"description": "Puts the sandbox garden back to the moment it was opened, undoing every fast-forward. Safe to call when the sandbox is closed: it does nothing then, and the state reports sandbox.open false. Changes nothing real. Returns the state afterwards.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}close-sandboxAction
Closes the page's time rehearsal and puts the page back to the real garden — the undo of open-sandbox. The rehearsal is for trying time away, so it must be put away again: this hides the rehearsal panel, offers the Rehearse time control once more, and discards the rehearsal whole. Nothing real changes — the real garden, its save and its last-seen moment are exactly as they were, and anything already earned or spent is not carried over. Safe to call when no sandbox is open: it does nothing then. Returns the state afterwards, whose sandbox field is {open: false} beside the untouched real garden.
View tool JSON
{
"name": "close-sandbox",
"kind": "act",
"impl": "imperative",
"description": "Closes the page's time rehearsal and puts the page back to the real garden — the undo of open-sandbox. The rehearsal is for trying time away, so it must be put away again: this hides the rehearsal panel, offers the Rehearse time control once more, and discards the rehearsal whole. Nothing real changes — the real garden, its save and its last-seen moment are exactly as they were, and anything already earned or spent is not carried over. Safe to call when no sandbox is open: it does nothing then. Returns the state afterwards, whose sandbox field is {open: false} beside the untouched real garden.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}export-saveAnswer
Returns the garden's one portable save string — the same value the page's Copy save button puts on the clipboard. Use it to carry a visitor's garden to another browser, or to keep it somewhere durable.
View tool JSON
{
"name": "export-save",
"kind": "answer",
"impl": "imperative",
"description": "Returns the garden's one portable save string — the same value the page's Copy save button puts on the clipboard. Use it to carry a visitor's garden to another browser, or to keep it somewhere durable.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}import-saveAction
Loads a save string from export-save into the whole garden and writes it to this browser. A load replaces everything the visitor is watching, so it is deliberately two steps and does not change the garden until confirmed: a call without confirm: true applies nothing and returns what the save holds beside what the garden holds now — current and incoming, each with growth, seeds, plants, beds and lifetime, and changes listing the fields that differ (from, to) — plus needsConfirmation: true and applied: false. Call again with confirm: true to load it; the return then carries applied: true, whether the browser kept it (persisted), and the state afterwards. An unreadable save is refused with its reason and the garden is left exactly as it was, confirmed or not.
View tool JSON
{
"name": "import-save",
"kind": "act",
"impl": "imperative",
"description": "Loads a save string from export-save into the whole garden and writes it to this browser. A load replaces everything the visitor is watching, so it is deliberately two steps and does not change the garden until confirmed: a call without confirm: true applies nothing and returns what the save holds beside what the garden holds now — current and incoming, each with growth, seeds, plants, beds and lifetime, and changes listing the fields that differ (from, to) — plus needsConfirmation: true and applied: false. Call again with confirm: true to load it; the return then carries applied: true, whether the browser kept it (persisted), and the state afterwards. An unreadable save is refused with its reason and the garden is left exactly as it was, confirmed or not.",
"inputSchema": {
"type": "object",
"properties": {
"save": {
"type": "string",
"description": "A save string produced by export-save (starts with SELFGROW1.)."
},
"confirm": {
"type": "boolean",
"description": "Set true to actually load the save. Omitted or false returns the preview and changes nothing."
}
},
"required": [
"save"
],
"additionalProperties": false
},
"page": "/selfgrow/"
}restore-saveAction
Does what the page's Restore previous garden button does, and is the one undo for import-save: it puts back the garden the most recent load replaced — the same growth, seeds, plants, beds, lifetime and lasting bonus it had — and writes it to this browser, so a wrong or regretted load costs the visitor nothing. get-state's restoreAvailable says whether there is such a garden: it is true only after a load has replaced one this session, and false once this tool has spent it or another load has replaced it. Safe to repeat: the first call spends the kept garden, so a second call changes nothing and reports restored: false with the reason. Returns whether it restored, what came back (restoredContents: growth, seeds, plants, beds and lifetime), whether the browser kept it (persisted), and the state afterwards.
View tool JSON
{
"name": "restore-save",
"kind": "act",
"impl": "imperative",
"description": "Does what the page's Restore previous garden button does, and is the one undo for import-save: it puts back the garden the most recent load replaced — the same growth, seeds, plants, beds, lifetime and lasting bonus it had — and writes it to this browser, so a wrong or regretted load costs the visitor nothing. get-state's restoreAvailable says whether there is such a garden: it is true only after a load has replaced one this session, and false once this tool has spent it or another load has replaced it. Safe to repeat: the first call spends the kept garden, so a second call changes nothing and reports restored: false with the reason. Returns whether it restored, what came back (restoredContents: growth, seeds, plants, beds and lifetime), whether the browser kept it (persisted), and the state afterwards.",
"inputSchema": {
"type": "object",
"properties": {},
"additionalProperties": false
},
"page": "/selfgrow/"
}