🦾 Give Codex ARMS: skills, routines, memory and apps, in Python · ติดแขน ARMS ให้ Codex: สกิล งานประจำ ความจำ และแอป ด้วย Python · 给 Codex 装上 ARMS：用 Python 做技能、例行任务、记忆和应用

1 make_workspace.py: one folder for everything · make_workspace.py: โฟลเดอร์เดียวสำหรับทุกอย่าง · make_workspace.py：一个文件夹装下一切

~/way1_by_hand.py

# Way 1: make each folder by hand, one line each.
import pathlib

home = pathlib.Path("practice")      # a folder to practise in
home.mkdir(exist_ok=True)

(home / "school").mkdir(exist_ok=True)
(home / "projects").mkdir(exist_ok=True)
(home / "notes").mkdir(exist_ok=True)
(home / "log").mkdir(exist_ok=True)
(home / "artifacts").mkdir(exist_ok=True)

print("Made 5 folders with 5 lines that look almost the same.")

python3 way1_by_hand.py

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

Made 5 folders with 5 lines that look almost the same.

~/arms/make_workspace.py

"""make_workspace.py - make the folders of your Codex workspace, each with a README.

    python3 make_workspace.py            in the folder you are in
    python3 make_workspace.py ~/arms     in that folder

A workspace is one folder that holds everything Codex works on for you. Each
folder inside it has one job, and its README.md says that job in its first line.
Codex reads that line, and so does make_map.py in step 9. Nothing that is
already there is changed, so the file is safe to run again.
"""
import pathlib
import sys

# Each folder, and the first line of its README.md.
FOLDERS = {
    "school": "Homework and class notes, one folder per subject.",
    "projects": "Programs I am building, one folder per project.",
    "notes": "Fixes for later: one file per skill, written by note.py.",
    "log": "What each Codex run cost, written by ask.py.",
    "artifacts": "Every web page Codex made for me, opened by inbox.py.",
}

# The workspace's AGENTS.md as it starts. make_map.py fills in the map.
AGENTS_START = """# AGENTS.md: how to work in this workspace

This folder is my workspace. Read the map first, then open only what you need.

## Rules

- Answer in short, plain English. I am a student.
- Save every web page you make in artifacts/, named like 2026-10-21-topic.html.
- Never delete a file. Move it to a folder named old/ instead.

## Map

<!-- map start -->
<!-- map end -->
"""

# A first page for artifacts/, so that inbox.py in step 13 has one to show.
WELCOME = """<!doctype html>
<title>Welcome</title>
<h1>My artifacts inbox</h1>
<p>Codex puts every page it makes for me in this folder.</p>
"""


def make(path, text):
    # Write a new file, but never over one that is already there.
    if path.exists():
        return "keep  "
    path.write_text(text, encoding="utf-8")
    return "create"


def main():
    # sys.argv[1] is the folder you named after the file name, if you named one.
    if len(sys.argv) > 1:
        home = pathlib.Path(sys.argv[1]).expanduser()
    else:
        home = pathlib.Path.cwd()
    home.mkdir(parents=True, exist_ok=True)
    for name, job in FOLDERS.items():
        folder = home / name
        folder.mkdir(exist_ok=True)
        state = make(folder / "README.md", "# " + name + "\n\n" + job + "\n")
        print(state, name + "/README.md")
    print(make(home / "AGENTS.md", AGENTS_START), "AGENTS.md")
    print(make(home / "artifacts" / "welcome.html", WELCOME), "artifacts/welcome.html")


if __name__ == "__main__":
    main()

python3 make_workspace.py

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

create school/README.md
create projects/README.md
create notes/README.md
create log/README.md
create artifacts/README.md
create AGENTS.md
create artifacts/welcome.html

# Quiz 1: what will this print?
FOLDERS = {"school": "Homework", "log": "Costs"}

for name, job in FOLDERS.items():
    print(name + "/README.md")

school/README.md
log/README.md

2 A skill that knows how you write · สกิลที่รู้ว่าคุณเขียนอย่างไร · 一个知道你怎么写作的技能

mkdir -p .agents/skills/my-voice
vim .agents/skills/my-voice/SKILL.md

~/arms/.agents/skills/my-voice/SKILL.md

---
name: my-voice
description: How I write, with examples. Use when asked to write or draft anything in my name - a message to a teacher, a post, a title, a short email - or to suggest ideas for titles or posts.
---

# How I write

Use the examples below to write the way I do. Do not copy them word for word.

## My rules

- Short sentences. One idea in each.
- Plain words. If a short word works, use it.
- Polite to teachers. Friendly to friends. No slang to teachers.
- Never more than one exclamation mark in a whole message.

## Examples

A message to a teacher:

> Good morning, Kru Nari. I was sick yesterday, so I missed the test.
> Can I take it on Friday? Thank you.

A post for my class group:

> Our science project is about the river at Mae Ping. We measure the water
> every Monday. Come and help if you are free.

A title for a video:

> How I fixed my bike chain in ten minutes

## Wild cards

When I ask for ideas (titles, posts, names), make most of them from my
examples, and make 2 of every 10 a wild card: an idea that does not follow my
examples at all. Write WILD CARD before each one. If I like a wild card, I will
ask you to add it to the examples above.

## Lessons

When I correct how you wrote something, add one short line here that says what
to do next time, with the date. Do not change anything else in this file.

not run by us: type this in a Codex chat in ~/armsเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชต Codex ที่ ~/arms我们没有运行过：在 ~/arms 的 Codex 对话里输入这一行

$my-voice give me 10 titles for a video about cleaning a bike chain

3 A skill that runs a Python checker · สกิลที่รันตัวตรวจภาษา Python · 一个运行 Python 检查程序的技能

mkdir -p .agents/skills/text-check

~/arms/.agents/skills/text-check/SKILL.md

---
name: text-check
description: Check a piece of my writing for words written twice and for sentences that are too long. Use when asked to "check my text", "check my homework" or "proofread" a .txt file.
---

# Check a text

Do not read the whole file yourself. Run the checker that comes with this skill,
and work from what it prints:

    python3 .agents/skills/text-check/check.py FILE

Then answer in this shape:

1. One line: how many words, sentences and problems the checker found.
2. Each problem, with a corrected version of that sentence.
3. Nothing else. Do not rewrite the parts the checker did not flag.

If the checker found no problems, say so in one line and stop.

## Lessons

When I correct how you did this check, add one short line here that says what
to do next time, with the date.

~/arms/.agents/skills/text-check/check.py

"""check.py - check a piece of writing for three simple mistakes, with no AI at all.

    python3 check.py homework.txt

It prints how many words and sentences the text has, every word written twice
in a row ("the the"), and every sentence longer than LONG words. A program like
this gives the same answer every time, costs nothing, and prints only a few
lines, so Codex reads a few lines instead of the whole text.
"""
import re
import sys

# A sentence with more words than this is called long.
LONG = 25


def sentences_of(text):
    # A sentence ends at . ! or ? and the spaces after it.
    parts = re.split(r"(?<=[.!?])\s+", text.strip())
    return [p for p in parts if p]


def main():
    text = open(sys.argv[1], encoding="utf-8").read()
    words = re.findall(r"[A-Za-z']+", text)
    sentences = sentences_of(text)
    print("words:", len(words))
    print("sentences:", len(sentences))
    problems = 0
    # zip pairs each word with the one after it.
    for first, second in zip(words, words[1:]):
        if first.lower() == second.lower():
            print("twice in a row:", first, second)
            problems += 1
    for number, sentence in enumerate(sentences, start=1):
        count = len(sentence.split())
        if count > LONG:
            print("long sentence", number, "has", count, "words:", sentence[:40] + "...")
            problems += 1
    print("problems:", problems)


if __name__ == "__main__":
    main()

~/arms/school/homework.txt

My village is near the Mae Ping river. Every morning I walk to school with my brother and we cross the the old bridge. In the rainy season the water comes up very high and the people who live near the river have to move their rice and their motorbikes and their chickens to the temple on the hill until the water goes down again. I like the dry season better.

run the checker yourself first, the way Codex willรันตัวตรวจเองก่อน แบบที่ Codex จะรัน先自己运行一下检查程序，就像 Codex 会做的那样

python3 .agents/skills/text-check/check.py school/homework.txt

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

words: 71
sentences: 4
twice in a row: the the
long sentence 3 has 41 words: In the rainy season the water comes up v...
problems: 2

not run by us: type this in a Codex chat in ~/armsเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชต Codex ที่ ~/arms我们没有运行过：在 ~/arms 的 Codex 对话里输入这一行

$text-check check school/homework.txt

# Quiz 3: what will this print?
sentence = "My village is near the river"
words = sentence.split()
print(len(words))
if len(words) > 5:
    print("long")

6
long

4 route.py: a small model for small jobs · route.py: โมเดลเล็กสำหรับงานเล็ก · route.py：小任务交给小模型

~/arms/route.py

"""route.py - send each job to the model it needs: a small one for easy jobs.

    python3 route.py "check homework.txt"          print the Codex command it would run
    python3 route.py --go "check homework.txt"     run that command

A big model costs more and is slower. Many jobs do not need it: checking a
text, making a list, a summary. This file looks at the first word of the job
and picks a model. The rule is simple on purpose: you can read it, and you can
change it when it picks wrong.
"""
import subprocess
import sys

BIG = "gpt-6.1-sol"
SMALL = "gpt-6-luna"
# A job that starts with one of these words goes to the small model.
SMALL_JOBS = ["check", "list", "summarize", "summarise", "rename", "translate", "spell"]


def pick_model(job):
    first_word = job.split()[0].lower()
    if first_word in SMALL_JOBS:
        return SMALL
    return BIG


def command_for(job):
    model = pick_model(job)
    command = ["codex", "exec", "-m", model]
    if model == SMALL:
        # -c changes one setting for this run only: here, less thinking.
        command += ["-c", "model_reasoning_effort=low"]
    return command + [job]


def main():
    go = "--go" in sys.argv
    jobs = [word for word in sys.argv[1:] if word != "--go"]
    for job in jobs:
        command = command_for(job)
        print(pick_model(job), "<-", job)
        if go:
            # stdin=DEVNULL: with no keyboard behind it,
            # codex exec would wait for more input.
            subprocess.run(command, stdin=subprocess.DEVNULL)
        else:
            print("   ", " ".join(command[:-1]), '"' + job + '"')


if __name__ == "__main__":
    main()

python3 route.py "check school/homework.txt" "make a quiz from my science notes" \
  "list my projects" "fix the bug in projects/game/main.py"

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

gpt-6-luna <- check school/homework.txt
    codex exec -m gpt-6-luna -c model_reasoning_effort=low "check school/homework.txt"
gpt-6.1-sol <- make a quiz from my science notes
    codex exec -m gpt-6.1-sol "make a quiz from my science notes"
gpt-6-luna <- list my projects
    codex exec -m gpt-6-luna -c model_reasoning_effort=low "list my projects"
gpt-6.1-sol <- fix the bug in projects/game/main.py
    codex exec -m gpt-6.1-sol "fix the bug in projects/game/main.py"

not run by us: this one starts Codexเราไม่ได้รันเอง: คำสั่งนี้เริ่ม Codex我们没有运行过：这一条会启动 Codex

python3 route.py --go "check school/homework.txt"

# Quiz 4: what will this print?
SMALL_JOBS = ["check", "list", "summarize"]
job = "Fix the bug in game.py"

first_word = job.split()[0].lower()
if first_word in SMALL_JOBS:
    print("small model")
else:
    print("big model")

big model

5 quiet_check.py: a routine that stays quiet · quiet_check.py: งานประจำที่อยู่เงียบ ๆ · quiet_check.py：一个保持安静的例行任务

~/arms/quiet_check.py

"""quiet_check.py - a quiet routine: say nothing unless a folder holds a big file.

    python3 quiet_check.py ~/Downloads 500           files over 500 MB, if any
    python3 quiet_check.py ~/Downloads 500 --ask     if there are, ask Codex about them

Python does the looking, and looking costs nothing. Codex is asked only when
there is something to ask about, so on most days this routine uses no tokens
and prints nothing at all. Nothing prints means nothing to read.
"""
import pathlib
import subprocess
import sys

# 1 MB is 1,000,000 bytes, the way a Mac's Finder counts.
MB = 1_000_000


def big_files(folder, limit_mb):
    found = []
    # rglob("*") walks into every folder inside this one, too.
    for path in folder.rglob("*"):
        if path.is_file() and path.stat().st_size > limit_mb * MB:
            found.append(path)
    return found


def main():
    folder = pathlib.Path(sys.argv[1]).expanduser()
    limit_mb = float(sys.argv[2])
    found = big_files(folder, limit_mb)
    if not found:
        return
    lines = []
    for path in found:
        size = path.stat().st_size / MB
        lines.append(f"{size:8.1f} MB  {path.relative_to(folder).as_posix()}")
    print("\n".join(lines))
    if "--ask" in sys.argv:
        job = ("These files in " + str(folder) + " are big. For each one, say in one "
               "line whether I can probably delete it, and why. Do not delete anything.\n"
               + "\n".join(lines))
        command = ["codex", "exec", "-m", "gpt-6-luna", job]
        # stdin=DEVNULL: with no keyboard behind it,
        # codex exec would wait for more input.
        subprocess.run(command, stdin=subprocess.DEVNULL)


if __name__ == "__main__":
    main()

python3 quiet_check.py ~/Downloads 1000

what it printed: nothingสิ่งที่มันพิมพ์ออกมา: ไม่มีอะไรเลย它打印的内容：什么也没有

python3 quiet_check.py ~/Downloads 500

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

   700.0 MB  old-game-installer.dmg

not run by us: with --ask it starts Codex, which says what each file probably isเราไม่ได้รันเอง: เมื่อมี --ask มันจะเริ่ม Codex ซึ่งบอกว่าแต่ละไฟล์น่าจะเป็นอะไร我们没有运行过：带上 --ask 它会启动 Codex，由 Codex 说出每个文件大概是什么

python3 quiet_check.py ~/Downloads 500 --ask

# Quiz 5: what will this print?
sizes = {"song.mp3": 2, "game.dmg": 700, "photo.jpg": 5}

for name, mb in sizes.items():
    if mb > 500:
        print(name)

game.dmg

6 Every Monday, by itself · ทุกวันจันทร์ โดยไม่ต้องสั่ง · 每个星期一，自己运行

which codex
crontab -e

not run by us: the two lines to type into the crontabเราไม่ได้รันเอง: สองบรรทัดที่ต้องพิมพ์ลงใน crontab我们没有运行过：要输入 crontab 的两行

PATH=/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin
0 9 * * 1 cd ~/arms && python3 quiet_check.py ~/Downloads 500 --ask >> log/quiet.txt 2>&1

7 ask.py: write down what each run cost · ask.py: จดว่าแต่ละครั้งที่รันใช้ไปเท่าไร · ask.py：记下每次运行花了多少

~/arms/ask.py

"""ask.py - the one door to Codex: run a job, write down what it cost, stop at a cap.

    python3 ask.py hand "summarize school/science/notes.md"     a job you typed
    python3 ask.py quiet "check ~/Downloads for big files"      a routine's job
    python3 ask.py --dry hand "list my projects"                show, run nothing

The first word after ask.py is a name you choose: "hand" for jobs you type
yourself, and one name for each routine. Every run adds one line to
log/asks.jsonl with the name, the job and the tokens Codex used. A name with a
weekly cap in CAPS is not run again once its last 7 days reach the cap.
week.py reads the same file and makes a report from it.
"""
import datetime
import json
import pathlib
import subprocess
import sys

LOG = pathlib.Path("log") / "asks.jsonl"
# Tokens a name may use in 7 days. A name not listed here has no cap.
CAPS = {"quiet": 50_000, "digest": 200_000}
SMALL = "gpt-6-luna"


def used_this_week(name):
    # Add up the tokens of every line with this name from the last 7 days.
    if not LOG.exists():
        return 0
    week_ago = datetime.datetime.now() - datetime.timedelta(days=7)
    total = 0
    for line in LOG.read_text(encoding="utf-8").splitlines():
        run = json.loads(line)
        when = datetime.datetime.fromisoformat(run["when"])
        if run["name"] == name and when > week_ago:
            total += run["input"] + run["output"]
    return total


def usage_of(events):
    # codex exec --json prints one event per line. "turn.completed" holds the tokens.
    for line in events.splitlines():
        if not line.startswith("{"):
            continue
        event = json.loads(line)
        if event.get("type") == "turn.completed":
            return event["usage"]
    return {}


def main():
    dry = "--dry" in sys.argv
    words = [word for word in sys.argv[1:] if word != "--dry"]
    name, job = words[0], words[1]
    used = used_this_week(name)
    cap = CAPS.get(name)
    if cap and used >= cap:
        print(f"skipped: {name} used {used:,} of its {cap:,} tokens this week")
        return
    LOG.parent.mkdir(exist_ok=True)
    answer_file = LOG.parent / ("last_" + name + ".txt")
    # An answer left from an earlier run must not pass for this run's answer.
    answer_file.unlink(missing_ok=True)
    command = ["codex", "exec", "--json", "-m", SMALL, "-o", answer_file.as_posix(), job]
    if dry:
        print(" ".join(command[:-1]), '"' + job + '"')
        print(f"{name} has used {used:,} tokens in the last 7 days")
        return
    # capture_output keeps the events here, so that Python can read the tokens.
    result = subprocess.run(command, capture_output=True, text=True,
                            stdin=subprocess.DEVNULL)
    usage = usage_of(result.stdout)
    run = {
        "when": datetime.datetime.now().isoformat(timespec="seconds"),
        "name": name,
        "job": job,
        "input": usage.get("input_tokens", 0),
        "cached": usage.get("cached_input_tokens", 0),
        "output": usage.get("output_tokens", 0),
    }
    with LOG.open("a", encoding="utf-8") as log:
        log.write(json.dumps(run) + "\n")
    # Codex writes its answer to answer_file. No file means it failed: show why.
    if answer_file.exists():
        print(answer_file.read_text(encoding="utf-8"))
    else:
        print(result.stderr)
    print(f"tokens: {run['input']:,} in ({run['cached']:,} of them cached), "
          f"{run['output']:,} out")


if __name__ == "__main__":
    main()

python3 ask.py --dry hand "check school/homework.txt"

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

codex exec --json -m gpt-6-luna -o log/last_hand.txt "check school/homework.txt"
hand has used 0 tokens in the last 7 days

not run by us: without --dry it starts Codex and writes the logเราไม่ได้รันเอง: ถ้าไม่มี --dry มันจะเริ่ม Codex และเขียนบันทึก我们没有运行过：不带 --dry 时它会启动 Codex 并写日志

python3 ask.py hand "check school/homework.txt"
python3 ask.py digest "summarize the newest notes in school/ in five lines"

# Quiz 7: what will this print?
CAPS = {"quiet": 50_000, "digest": 200_000}
used = 60_000
name = "hand"

cap = CAPS.get(name)
if cap and used >= cap:
    print("skipped")
else:
    print("run")

run

8 week.py: caps and repeats · week.py: เพดานและงานที่ทำซ้ำ · week.py：上限和重复的任务

~/arms/week.py

"""week.py - a weekly report from ask.py's log: what each name cost, and what you repeat.

    python3 week.py                         read log/asks.jsonl
    python3 week.py example_asks.jsonl      read another log, such as the page's example

Part 1 adds up the tokens of each name over the last 7 days, next to its cap.
Part 2 looks at the jobs you typed yourself (the name "hand") and lists every
job you typed 3 times or more. A job you keep typing by hand is a routine that
nobody has written yet.
"""
import collections
import datetime
import json
import pathlib
import re
import sys

# The same caps as in ask.py. Change them in both files.
CAPS = {"quiet": 50_000, "digest": 200_000}
REPEATS = 3


def same_job(job):
    # "Summarize notes.md!" and "summarize notes.md" are the same job.
    return re.sub(r"[^a-z0-9 ./_-]", "", job.lower()).strip()


def main():
    log = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "log/asks.jsonl")
    runs = [json.loads(line) for line in log.read_text(encoding="utf-8").splitlines()]
    # The newest run in the log is "now", so an old log still makes a report.
    now = max(datetime.datetime.fromisoformat(run["when"]) for run in runs)
    week_ago = now - datetime.timedelta(days=7)
    tokens = collections.Counter()
    count = collections.Counter()
    for run in runs:
        if datetime.datetime.fromisoformat(run["when"]) > week_ago:
            tokens[run["name"]] += run["input"] + run["output"]
            count[run["name"]] += 1
    print("LAST 7 DAYS        runs      tokens         cap")
    for name, used in tokens.most_common():
        cap = CAPS.get(name)
        cap_text = f"{cap:,}" if cap else "-"
        flag = "  OVER" if cap and used > cap else ""
        print(f"  {name:<14}{count[name]:>6}{used:>12,}{cap_text:>12}{flag}")
    by_hand = [same_job(run["job"]) for run in runs if run["name"] == "hand"]
    typed = collections.Counter(by_hand)
    print()
    print(f"TYPED BY HAND {REPEATS} TIMES OR MORE: make these routines")
    for job, times in typed.most_common():
        if times >= REPEATS:
            print(f"  {times} x  {job}")


if __name__ == "__main__":
    main()

~/arms/example_asks.jsonl (made up, for the example)(สมมุติขึ้น เพื่อเป็นตัวอย่าง)（编出来的，作为例子）

{"when": "2026-10-14T19:12:40", "name": "hand", "job": "check school/english/essay.txt", "input": 6110, "cached": 0, "output": 420}
{"when": "2026-10-15T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 31200, "cached": 24100, "output": 1900}
{"when": "2026-10-16T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 33950, "cached": 25800, "output": 2100}
{"when": "2026-10-16T20:03:15", "name": "hand", "job": "Check school/english/essay.txt!", "input": 6240, "cached": 3100, "output": 390}
{"when": "2026-10-17T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 29870, "cached": 23300, "output": 1700}
{"when": "2026-10-17T18:44:02", "name": "hand", "job": "make a quiz from school/science/notes.md", "input": 14880, "cached": 0, "output": 2650}
{"when": "2026-10-18T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 35400, "cached": 27700, "output": 2300}
{"when": "2026-10-18T21:30:09", "name": "hand", "job": "check school/english/essay.txt", "input": 6020, "cached": 3050, "output": 410}
{"when": "2026-10-19T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 32010, "cached": 24900, "output": 2000}
{"when": "2026-10-20T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 30660, "cached": 23800, "output": 1800}
{"when": "2026-10-20T09:00:11", "name": "quiet", "job": "These files are big. For each one, say whether I can delete it.", "input": 8420, "cached": 0, "output": 610}
{"when": "2026-10-20T19:55:47", "name": "hand", "job": "list my projects and what is unfinished in each", "input": 11930, "cached": 0, "output": 1340}
{"when": "2026-10-21T07:00:04", "name": "digest", "job": "summarize the newest notes in school/ in five lines", "input": 34120, "cached": 26500, "output": 2200}
{"when": "2026-10-21T20:10:33", "name": "hand", "job": "check school/english/essay.txt", "input": 6180, "cached": 3080, "output": 400}

python3 week.py example_asks.jsonl

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

LAST 7 DAYS        runs      tokens         cap
  digest             7     241,210     200,000  OVER
  hand               5      50,440           -
  quiet              1       9,030      50,000

TYPED BY HAND 3 TIMES OR MORE: make these routines
  4 x  check school/english/essay.txt

# Quiz 8: what will this print?
import collections

jobs = ["check essay", "list projects", "check essay", "check essay"]
counts = collections.Counter(jobs)
print(counts["check essay"])

3

9 make_map.py: a map in AGENTS.md · make_map.py: แผนที่ใน AGENTS.md · make_map.py：AGENTS.md 里的一张地图

~/arms/make_map.py

"""make_map.py - write a map of the workspace into its AGENTS.md.

    python3 make_map.py            in your workspace

Codex reads AGENTS.md at the start of every chat. A map there tells it where
things are, so it opens one folder instead of searching all of them. The map is
each folder, the first line of its README.md, and how many files it holds. Run
this again whenever you add a folder: it replaces the old map and nothing else.
"""
import pathlib

START = "<!-- map start -->"
END = "<!-- map end -->"


def first_line(readme):
    # The first line that is not empty and not a heading says the folder's job.
    for line in readme.read_text(encoding="utf-8").splitlines():
        if line.strip() and not line.startswith("#"):
            return line.strip()
    return "(no README.md line)"


def map_lines(home):
    lines = []
    for folder in sorted(p for p in home.iterdir() if p.is_dir()):
        # A name that starts with a dot, like .git or .agents, is a tool's folder.
        if folder.name.startswith("."):
            continue
        readme = folder / "README.md"
        job = first_line(readme) if readme.exists() else "(no README.md)"
        files = sum(1 for p in folder.rglob("*") if p.is_file())
        lines.append(f"- `{folder.name}/`: {job} (files: {files})")
    return lines


def main():
    home = pathlib.Path.cwd()
    agents = home / "AGENTS.md"
    text = agents.read_text(encoding="utf-8")
    before = text.split(START)[0]
    after = text.split(END)[1]
    new_map = "\n".join([START] + map_lines(home) + [END])
    agents.write_text(before + new_map + after, encoding="utf-8")
    print(new_map)


if __name__ == "__main__":
    main()

python3 make_map.py

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

<!-- map start -->
- `artifacts/`: Every web page Codex made for me, opened by inbox.py. (files: 2)
- `log/`: What each Codex run cost, written by ask.py. (files: 1)
- `notes/`: Fixes for later: one file per skill, written by note.py. (files: 1)
- `projects/`: Programs I am building, one folder per project. (files: 1)
- `school/`: Homework and class notes, one folder per subject. (files: 2)
<!-- map end -->

~/arms/AGENTS.md afterwards~/arms/AGENTS.md หลังจากนั้น之后的 ~/arms/AGENTS.md

# AGENTS.md: how to work in this workspace

This folder is my workspace. Read the map first, then open only what you need.

## Rules

- Answer in short, plain English. I am a student.
- Save every web page you make in artifacts/, named like 2026-10-21-topic.html.
- Never delete a file. Move it to a folder named old/ instead.

## Map

<!-- map start -->
- `artifacts/`: Every web page Codex made for me, opened by inbox.py. (files: 2)
- `log/`: What each Codex run cost, written by ask.py. (files: 1)
- `notes/`: Fixes for later: one file per skill, written by note.py. (files: 1)
- `projects/`: Programs I am building, one folder per project. (files: 1)
- `school/`: Homework and class notes, one folder per subject. (files: 2)
<!-- map end -->

# Quiz 9: what will this print?
readme = """# school

Homework and class notes."""

for line in readme.splitlines():
    if line.strip() and not line.startswith("#"):
        print(line)
        break

Homework and class notes.

10 how_big.py: the memory of one chat · how_big.py: ความจำของแชตหนึ่งแชต · how_big.py：一次对话的记忆

~/arms/how_big.py

"""how_big.py - how many tokens would it cost Codex to read every file here?

    python3 how_big.py            in your workspace

A token is a piece of a word. For English, 4 letters make about 1 token, so
this divides each file's size by 4. That is a guess, not a count, but it is
close enough to show the point: reading everything costs far more than reading
the map in AGENTS.md first. It also checks AGENTS.md against Codex's limit:
Codex reads at most 32 KiB of it, and quietly drops the rest.
"""
import pathlib

LETTERS_PER_TOKEN = 4
AGENTS_LIMIT = 32 * 1024


def main():
    home = pathlib.Path.cwd()
    sizes = {}
    for path in home.rglob("*"):
        # Files inside .git are git's own records, not your work.
        if path.is_file() and ".git" not in path.parts:
            sizes[path.relative_to(home)] = path.stat().st_size
    total = sum(sizes.values()) // LETTERS_PER_TOKEN
    biggest = sorted(sizes, key=sizes.get, reverse=True)[:5]
    print(f"{len(sizes)} files, about {total:,} tokens to read them all")
    print("the biggest:")
    for name in biggest:
        print(f"  {sizes[name] // LETTERS_PER_TOKEN:>8,} tokens  {name.as_posix()}")
    agents = sizes.get(pathlib.Path("AGENTS.md"), 0)
    state = "fine" if agents <= AGENTS_LIMIT else "TOO BIG: Codex drops the end"
    print(f"AGENTS.md: {agents:,} bytes of {AGENTS_LIMIT:,}, about "
          f"{agents // LETTERS_PER_TOKEN:,} tokens: {state}")


if __name__ == "__main__":
    main()

python3 how_big.py

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

23 files, about 6,888 tokens to read them all
the biggest:
       901 tokens  ask.py
       644 tokens  make_workspace.py
       610 tokens  inbox.py
       556 tokens  week.py
       531 tokens  example_asks.jsonl
AGENTS.md: 766 bytes of 32,768, about 191 tokens: fine

# Quiz 10: what will this print?
LETTERS_PER_TOKEN = 4
text = "Check my homework."

print(len(text), "letters")
print(len(text) // LETTERS_PER_TOKEN, "tokens, about")

18 letters
4 tokens, about

11 note.py: fixes for later · note.py: สิ่งที่จะแก้ทีหลัง · note.py：留到以后的修改

~/arms/note.py

"""note.py - park a fix for later, so that you do not break off what you are doing.

    python3 note.py text-check "say the line number of each problem"    add a note
    python3 note.py                                                     count the notes

Each skill gets its own file in notes/, one line per fix, with the date. When
you have time, ask Codex to apply them all at once (step 11 shows how). Writing
the note costs nothing, because Python writes it, not Codex.
"""
import datetime
import pathlib
import sys

NOTES = pathlib.Path("notes")


def main():
    NOTES.mkdir(exist_ok=True)
    if len(sys.argv) == 3:
        skill, fix = sys.argv[1], sys.argv[2]
        today = datetime.date.today().isoformat()
        with (NOTES / (skill + ".md")).open("a", encoding="utf-8") as notes:
            notes.write(f"- [ ] {today} {fix}\n")
    # Count the open notes, the lines that start with "- [ ]", in each file.
    for path in sorted(NOTES.glob("*.md")):
        lines = path.read_text(encoding="utf-8").splitlines()
        open_notes = [line for line in lines if line.startswith("- [ ]")]
        if open_notes:
            print(f"{len(open_notes)} open  notes/{path.name}")


if __name__ == "__main__":
    main()

python3 note.py text-check "say the line number of each problem"

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

1 open  notes/text-check.md

not run by us: type this in a Codex chat in ~/armsเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชต Codex ที่ ~/arms我们没有运行过：在 ~/arms 的 Codex 对话里输入这几行

Read notes/text-check.md. Apply every open note to .agents/skills/text-check,
then change "- [ ]" to "- [x]" on each note you applied.

~/.codex/config.toml

[features]
memories = true

# Quiz 11: what will this print?
import pathlib

notes = pathlib.Path("notes.md")
notes.write_text("one\n", encoding="utf-8")
with notes.open("a", encoding="utf-8") as file:
    file.write("two\n")
print(notes.read_text(encoding="utf-8"), end="")

one
two

12 weather.py: a command, not a whole answer · weather.py: คำสั่งหนึ่งคำสั่ง ไม่ใช่คำตอบทั้งก้อน · weather.py：一条命令，而不是一整份回答

~/arms/weather.py

"""weather.py - a small command that Codex can run: today's weather in Chiang Mai.

    python3 weather.py           one line: what Codex needs
    python3 weather.py --raw     the whole answer of the weather service, and its size

The weather comes from Open-Meteo, a free service with no key. Its answer is
long, and most of it is not the weather. This command reads the answer and
prints one line. Give Codex the command and it reads one line; give it the
service and it reads the whole answer, every time.
"""
import json
import sys
import urllib.request

# Chiang Mai: latitude 18.79 north, longitude 98.98 east.
URL = ("https://api.open-meteo.com/v1/forecast?latitude=18.79&longitude=98.98"
       "&current=temperature_2m,relative_humidity_2m,precipitation,wind_speed_10m"
       "&hourly=temperature_2m,precipitation_probability&timezone=Asia%2FBangkok")


def main():
    with urllib.request.urlopen(URL, timeout=20) as response:
        raw = response.read().decode("utf-8")
    if "--raw" in sys.argv:
        print(raw[:300] + " ...")
        print(len(raw), "characters in the whole answer")
        return
    now = json.loads(raw)["current"]
    line = (f"Chiang Mai {now['time']}: {now['temperature_2m']} C, "
            f"humidity {now['relative_humidity_2m']}%, rain {now['precipitation']} mm, "
            f"wind {now['wind_speed_10m']} km/h")
    print(line)
    print(len(line), "characters")


if __name__ == "__main__":
    main()

python3 weather.py
python3 weather.py --raw

what the first command printedสิ่งที่คำสั่งแรกพิมพ์ออกมา第一条命令打印的内容

Chiang Mai 2026-10-25T12:45: 32.0 C, humidity 55%, rain 0.0 mm, wind 4.6 km/h
77 characters

what the second command printed: the start of the answer, and its sizeสิ่งที่คำสั่งที่สองพิมพ์ออกมา: ตอนต้นของคำตอบ และขนาดของมัน第二条命令打印的内容：回答的开头，以及它的大小

{"latitude":18.80492,"longitude":99.02655,"generationtime_ms":0.0833272933959961,"utc_offset_seconds":25200,"timezone":"Asia/Bangkok","timezone_abbreviation":"GMT+7","elevation":315.0,"current_units":{"time":"iso8601","interval":"seconds","temperature_2m":"°C","relative_humidity_2m":"%","precipitati ...
5109 characters in the whole answer

13 inbox.py: an app of your own · inbox.py: แอปของคุณเอง · inbox.py：你自己的应用

~/arms/inbox.py

"""inbox.py - a small app of your own: every page Codex made for you, newest first.

    python3 inbox.py             open http://localhost:8765 in your browser
    python3 inbox.py --list      print the list here instead

AGENTS.md tells Codex to save every web page it makes in artifacts/. This app
lists them, with a search box, so you can find last week's page yourself
instead of asking Codex to look for it, which costs tokens. It uses only
Python's own http.server. Press Ctrl+C in the terminal to stop it.
"""
import datetime
import html
import http.server
import pathlib
import sys
import urllib.parse

FOLDER = pathlib.Path("artifacts")
PORT = 8765


def pages(search=""):
    found = [p for p in FOLDER.glob("*.html") if search.lower() in p.name.lower()]
    # Newest first: sort by the time each file was last changed.
    return sorted(found, key=lambda p: p.stat().st_mtime, reverse=True)


def when(path):
    changed = datetime.datetime.fromtimestamp(path.stat().st_mtime)
    return changed.strftime("%Y-%m-%d %H:%M")


def list_page(search):
    rows = ""
    for path in pages(search):
        name = html.escape(path.name)
        rows += f'<li><a href="/artifacts/{name}">{name}</a> {when(path)}</li>\n'
    return (f"<!doctype html><title>Inbox</title><h1>Inbox</h1>"
            f'<form><input name="q" value="{html.escape(search)}" placeholder="search">'
            f"<button>Find</button></form><ul>{rows}</ul>")


class Inbox(http.server.SimpleHTTPRequestHandler):
    # SimpleHTTPRequestHandler already sends any file asked for, such as
    # /artifacts/welcome.html. Only the front page, "/", is made here.
    def do_GET(self):
        address = urllib.parse.urlparse(self.path)
        if address.path != "/":
            return super().do_GET()
        search = urllib.parse.parse_qs(address.query).get("q", [""])[0]
        body = list_page(search).encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.end_headers()
        self.wfile.write(body)


def main():
    if "--list" in sys.argv:
        for path in pages():
            print(when(path), path.name)
        return
    # "localhost" means only this computer can open the page.
    server = http.server.HTTPServer(("localhost", PORT), Inbox)
    print(f"inbox on http://localhost:{PORT} (Ctrl+C stops it)")
    server.serve_forever()


if __name__ == "__main__":
    main()

python3 inbox.py --list

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

2026-10-25 12:56 2026-10-21-mae-ping-river.html
2026-10-25 12:56 welcome.html

python3 inbox.py

what it printed, and the page it sent for a search for riverสิ่งที่มันพิมพ์ออกมา และหน้าที่มันส่งมาเมื่อค้นหาคำว่า river它打印的内容，以及搜索 river 时它送回的网页

inbox on http://localhost:8765 (Ctrl+C stops it)

GET /?q=river
<!doctype html>
<title>Inbox</title>
<h1>Inbox</h1>
<form>
<input name="q" value="river" placeholder="search">
<button>Find</button>
</form>
<ul>
<li>
<a href="/artifacts/2026-10-21-mae-ping-river.html">2026-10-21-mae-ping-river.html</a> 2026-10-25 12:56</li>
</ul>

# Quiz 13: what will this print?
pages = ["2026-10-14-moon.html", "2026-10-21-river.html", "2026-10-18-rice.html"]

for page in sorted(pages, reverse=True):
    print(page)

2026-10-21-river.html
2026-10-18-rice.html
2026-10-14-moon.html

G1 The same workspace, read by Antigravity · พื้นที่ทำงานเดิม ให้ Antigravity อ่าน · 同一个工作区，由 Antigravity 来读

G2 my-voice, called with / · my-voice เรียกด้วย / · my-voice，用 / 来叫

not run by us: type this in an agy chat in ~/armsเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชตของ agy ใน ~/arms我们没有运行过：在 ~/arms 里的 agy 对话中输入

/my-voice give me 10 titles for a video about cleaning a bike chain

G3 text-check, and agy asks before it runs check.py · text-check และ agy ถามก่อนรัน check.py · text-check，agy 运行 check.py 前会先问

not run by us: type this in an agy chatเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชตของ agy我们没有运行过：在 agy 对话中输入

/text-check check school/homework.txt

G4 gemini_route.py: low effort for small jobs · gemini_route.py: คิดน้อยสำหรับงานเล็ก · gemini_route.py：小任务少想一点

~/arms/gemini_route.py

"""gemini_route.py - send each job to the effort it needs: low effort for easy jobs.

    python3 gemini_route.py "check homework.txt"          print the agy command it would run
    python3 gemini_route.py --go "check homework.txt"     run that command

agy, the Antigravity CLI, runs Google's Gemini models. For each job you choose
how hard the model thinks: --effort low, medium or high. More thinking takes
longer and uses more of your quota. Many jobs do not need it: checking a text,
making a list, a summary. This file looks at the first word of the job and
picks the effort. The rule is simple on purpose: you can read it, and you can
change it when it picks wrong.
"""
import subprocess
import sys

# A model's name, copied exactly from what `agy models` prints. "" means agy's own choice.
MODEL = ""
# A job that starts with one of these words gets low effort.
SMALL_JOBS = ["check", "list", "summarize", "summarise", "rename", "translate", "spell"]


def pick_effort(job):
    first_word = job.split()[0].lower()
    if first_word in SMALL_JOBS:
        return "low"
    return "high"


def command_for(job):
    command = ["agy", "--effort", pick_effort(job)]
    if MODEL:
        command += ["--model", MODEL]
    # -p runs agy for this one job, without a chat, and then stops.
    return command + ["-p", job]


def main():
    go = "--go" in sys.argv
    jobs = [word for word in sys.argv[1:] if word != "--go"]
    for job in jobs:
        command = command_for(job)
        print(pick_effort(job), "<-", job)
        if go:
            # stdin=DEVNULL: with no keyboard behind it,
            # agy could wait for more input.
            subprocess.run(command, stdin=subprocess.DEVNULL)
        else:
            print("   ", " ".join(command[:-1]), '"' + job + '"')


if __name__ == "__main__":
    main()

python3 gemini_route.py "check school/homework.txt" "make a quiz from my science notes" \
  "list my projects" "fix the bug in projects/game/main.py"

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

low <- check school/homework.txt
    agy --effort low -p "check school/homework.txt"
high <- make a quiz from my science notes
    agy --effort high -p "make a quiz from my science notes"
low <- list my projects
    agy --effort low -p "list my projects"
high <- fix the bug in projects/game/main.py
    agy --effort high -p "fix the bug in projects/game/main.py"

not run by us: this one starts agyเราไม่ได้รันเอง: คำสั่งนี้เริ่ม agy我们没有运行过：这一条会启动 agy

agy models
python3 gemini_route.py --go "check school/homework.txt"

G5 gemini_quiet_check.py: the quiet routine · gemini_quiet_check.py: งานประจำที่อยู่เงียบ ๆ · gemini_quiet_check.py：安静的例行任务

~/arms/gemini_quiet_check.py

"""gemini_quiet_check.py - a quiet routine: say nothing unless a folder holds a big file.

    python3 gemini_quiet_check.py ~/Downloads 500           files over 500 MB, if any
    python3 gemini_quiet_check.py ~/Downloads 500 --ask     if there are, ask Gemini about them

Python does the looking, and looking costs nothing. Gemini is asked only when
there is something to ask about, so on most days this routine uses no quota
and prints nothing at all. Nothing prints means nothing to read.
"""
import pathlib
import subprocess
import sys

# 1 MB is 1,000,000 bytes, the way a Mac's Finder counts.
MB = 1_000_000


def big_files(folder, limit_mb):
    found = []
    # rglob("*") walks into every folder inside this one, too.
    for path in folder.rglob("*"):
        if path.is_file() and path.stat().st_size > limit_mb * MB:
            found.append(path)
    return found


def main():
    folder = pathlib.Path(sys.argv[1]).expanduser()
    limit_mb = float(sys.argv[2])
    found = big_files(folder, limit_mb)
    if not found:
        return
    lines = []
    for path in found:
        size = path.stat().st_size / MB
        lines.append(f"{size:8.1f} MB  {path.relative_to(folder).as_posix()}")
    print("\n".join(lines))
    if "--ask" in sys.argv:
        job = ("These files in " + str(folder) + " are big. For each one, say in one "
               "line whether I can probably delete it, and why. Do not delete anything.\n"
               + "\n".join(lines))
        command = ["agy", "--effort", "low", "-p", job]
        # stdin=DEVNULL: with no keyboard behind it,
        # agy could wait for more input.
        subprocess.run(command, stdin=subprocess.DEVNULL)


if __name__ == "__main__":
    main()

python3 gemini_quiet_check.py ~/Downloads 500

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

   700.0 MB  old-game-installer.dmg

not run by us: with --ask it starts agyเราไม่ได้รันเอง: เมื่อมี --ask มันจะเริ่ม agy我们没有运行过：加上 --ask 就会启动 agy

python3 gemini_quiet_check.py ~/Downloads 500 --ask

G6 Every Monday: cron, not /schedule · ทุกวันจันทร์: ใช้ cron ไม่ใช่ /schedule · 每个星期一：用 cron，不用 /schedule

not run by us: in the Terminalเราไม่ได้รันเอง: ใน Terminal我们没有运行过：在终端里

which agy
crontab -e

not run by us: the two lines to type into the crontab, with your own nameเราไม่ได้รันเอง: สองบรรทัดที่ต้องพิมพ์ลงใน crontab โดยใส่ชื่อของคุณเอง我们没有运行过：要输入 crontab 的两行，换上你自己的名字

PATH=/Users/YOUR-NAME/.local/bin:/usr/bin:/bin
0 9 * * 1 cd ~/arms && python3 gemini_quiet_check.py ~/Downloads 500 --ask >> log/quiet.txt 2>&1

G7 gemini_ask.py: write down what each run cost · gemini_ask.py: จดว่าแต่ละครั้งที่รันใช้ไปเท่าไร · gemini_ask.py：记下每次运行花了多少

~/arms/gemini_ask.py

"""gemini_ask.py - the one door to Gemini: run a job, write down what it cost, stop at a cap.

    python3 gemini_ask.py hand "summarize school/science/notes.md"     a job you typed
    python3 gemini_ask.py quiet "check ~/Downloads for big files"      a routine's job
    python3 gemini_ask.py --dry hand "list my projects"                show, run nothing

The first word after gemini_ask.py is a name you choose: "hand" for jobs you
type yourself, and one name for each routine. Every run adds one line to
log/asks.jsonl with the name, the job and the tokens Gemini used. A name with a
weekly cap in CAPS is not run again once its last 7 days reach the cap.
week.py reads the same file and makes a report from it.
"""
import datetime
import json
import pathlib
import subprocess
import sys

LOG = pathlib.Path("log") / "asks.jsonl"
# Tokens a name may use in 7 days. A name not listed here has no cap.
CAPS = {"quiet": 50_000, "digest": 200_000}
EFFORT = "low"


def used_this_week(name):
    # Add up the tokens of every line with this name from the last 7 days.
    if not LOG.exists():
        return 0
    week_ago = datetime.datetime.now() - datetime.timedelta(days=7)
    total = 0
    for line in LOG.read_text(encoding="utf-8").splitlines():
        run = json.loads(line)
        when = datetime.datetime.fromisoformat(run["when"])
        if run["name"] == name and when > week_ago:
            total += run["input"] + run["output"]
    return total


def reply_of(text):
    # agy --output-format json prints one JSON object. No object means it failed.
    if not text.strip().startswith("{"):
        return {}
    return json.loads(text)


def main():
    dry = "--dry" in sys.argv
    words = [word for word in sys.argv[1:] if word != "--dry"]
    name, job = words[0], words[1]
    used = used_this_week(name)
    cap = CAPS.get(name)
    if cap and used >= cap:
        print(f"skipped: {name} used {used:,} of its {cap:,} tokens this week")
        return
    # --print-timeout: a routine that nobody watches must not wait for ever.
    command = ["agy", "--output-format", "json", "--effort", EFFORT,
               "--print-timeout", "10m", "-p", job]
    if dry:
        print(" ".join(command[:-1]), '"' + job + '"')
        print(f"{name} has used {used:,} tokens in the last 7 days")
        return
    # capture_output keeps the answer here, so that Python can read the tokens.
    result = subprocess.run(command, capture_output=True, text=True,
                            stdin=subprocess.DEVNULL)
    reply = reply_of(result.stdout)
    usage = reply.get("usage", {})
    run = {
        "when": datetime.datetime.now().isoformat(timespec="seconds"),
        "name": name,
        "job": job,
        "input": usage.get("input_tokens", 0),
        "cached": usage.get("cache_read_tokens", 0),
        "output": usage.get("output_tokens", 0),
    }
    LOG.parent.mkdir(exist_ok=True)
    with LOG.open("a", encoding="utf-8") as log:
        log.write(json.dumps(run) + "\n")
    # "SUCCESS" means agy finished the job. Anything else: show why it did not.
    if reply.get("status") == "SUCCESS":
        print(reply["response"])
    else:
        print(result.stderr)
    print(f"tokens: {run['input']:,} in ({run['cached']:,} of them cached), "
          f"{run['output']:,} out")


if __name__ == "__main__":
    main()

python3 gemini_ask.py --dry hand "check school/homework.txt"

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

agy --output-format json --effort low --print-timeout 10m -p "check school/homework.txt"
hand has used 0 tokens in the last 7 days

not run by us: ~/.gemini/antigravity-cli/settings.jsonเราไม่ได้รันเอง: ~/.gemini/antigravity-cli/settings.json我们没有运行过：~/.gemini/antigravity-cli/settings.json

{
  "permissions": {
    "allow": ["command(regex:python3 .agents/skills/text-check/check.py .*)"]
  }
}

not run by us: without --dry it starts agyเราไม่ได้รันเอง: ถ้าไม่มี --dry มันจะเริ่ม agy我们没有运行过：不加 --dry 就会启动 agy

python3 gemini_ask.py hand "check school/homework.txt"
python3 gemini_ask.py digest "summarize the newest notes in school/ in five lines"

G8 week.py, unchanged · week.py ไม่ต้องแก้ · week.py，原样不动

G9 make_map.py: one map for both · make_map.py: แผนที่เดียวสำหรับทั้งสอง · make_map.py：两个共用一张地图

G10 gemini_how_big.py, and /context instead of /status · gemini_how_big.py และ /context แทน /status · gemini_how_big.py，用 /context 代替 /status

~/arms/gemini_how_big.py

"""gemini_how_big.py - how many tokens would it cost Gemini to read every file here?

    python3 gemini_how_big.py            in your workspace

A token is a piece of a word. For English, 4 letters make about 1 token, so
this divides each file's size by 4. That is a guess, not a count, but it is
close enough to show the point: reading everything costs far more than reading
the map in AGENTS.md first. It also checks AGENTS.md against Antigravity's
limit: it reads at most 24,000 bytes of a rule file, and cuts off the rest.
"""
import pathlib

LETTERS_PER_TOKEN = 4
RULE_FILE_LIMIT = 24_000


def main():
    home = pathlib.Path.cwd()
    sizes = {}
    for path in home.rglob("*"):
        # Files inside .git are git's own records, not your work.
        if path.is_file() and ".git" not in path.parts:
            sizes[path.relative_to(home)] = path.stat().st_size
    total = sum(sizes.values()) // LETTERS_PER_TOKEN
    biggest = sorted(sizes, key=sizes.get, reverse=True)[:5]
    print(f"{len(sizes)} files, about {total:,} tokens to read them all")
    print("the biggest:")
    for name in biggest:
        print(f"  {sizes[name] // LETTERS_PER_TOKEN:>8,} tokens  {name.as_posix()}")
    agents = sizes.get(pathlib.Path("AGENTS.md"), 0)
    state = "fine" if agents <= RULE_FILE_LIMIT else "TOO BIG: Antigravity cuts the end"
    print(f"AGENTS.md: {agents:,} bytes of {RULE_FILE_LIMIT:,}, about "
          f"{agents // LETTERS_PER_TOKEN:,} tokens: {state}")


if __name__ == "__main__":
    main()

python3 gemini_how_big.py

what it printedสิ่งที่มันพิมพ์ออกมา它打印的内容

23 files, about 6,848 tokens to read them all
the biggest:
       838 tokens  gemini_ask.py
       644 tokens  make_workspace.py
       610 tokens  inbox.py
       556 tokens  week.py
       531 tokens  example_asks.jsonl
AGENTS.md: 766 bytes of 24,000, about 191 tokens: fine

G11 note.py, and /learn instead of Memories · note.py และ /learn แทน Memories · note.py，用 /learn 代替 Memories

not run by us: type this in an agy chat, after you corrected itเราไม่ได้รันเอง: พิมพ์สิ่งนี้ในแชตของ agy หลังจากที่คุณแก้มันแล้ว我们没有运行过：纠正过它之后，在 agy 对话中输入

/learn

G12 weather.py, and where MCP servers go · weather.py และที่ที่เซิร์ฟเวอร์ MCP อยู่ · weather.py，以及 MCP 服务器放在哪里

G13 inbox.py, unchanged · inbox.py ไม่ต้องแก้ · inbox.py，原样不动