# Cell-lct rebuilds a raster figure as Illustrator paths you can still edit

> Cell-lct is a Windows-only Codex Skill that turns a reference image into native Illustrator paths plus real SVG text on an artboard you already have open. It is built for scientists who need a figure editable after the fact, and it costs an API key, a Codex task with image editing, and a credit per run.

**yrui-cmd/cell-lct** — Cell-lct：面向 Adobe Illustrator 的可编辑科研矢量绘图插件。免费额度每天抖音群里提供，抖音名（木纹），私人额度小红书找：木纹小路

- Repository: https://github.com/yrui-cmd/cell-lct
- Stars: 384 · Forks: 15
- Language: PowerShell
- License: MIT
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/yrui-cmd-cell-lct

## It writes into an artboard you already have open, and only appends

Cell-lct exists for a specific irritation: a figure you hold only as a raster, a paper graphic, a screenshot from a collaborator, something you need to redraw for a thesis, a slide or a poster, and redrawing it by hand is slower than scripting it. What comes back is not a trace and not a flattened image. You get native editable paths, lettering restored as real SVG text rather than outlines, and the original drawing order preserved along with compound paths and holes. A PNG preview is exported only at the end of the run.

Two constraints shape everything else. First, the artboard is append-only: nothing already there is deleted, hidden or replaced, which is why the setup instructs you to open Illustrator 2026 and the target document yourself before sending the task. Second, the whole thing is a Codex Skill, not an Illustrator plug-in in the menu-bar sense. The source sits at `plugins/cell-lct` in the repository, and the installer copies the `cell-lct` Skill into your Codex Skills directory. You drive it by describing a task in words, not by clicking a panel. An original Cell-lct and this one can sit side by side without collision.

## Text is recorded first, then Image 2 erases it

Sequence is the whole design here. The first pass records what the lettering in the reference image says and where it sits: content, position, size, font, weight, colour, rotation, alignment and layer. Only after that does Image 2 clear the text while keeping arrows, boxes, coordinate axes, heatmaps, legends, the scientific subject itself and the original layout.

Text that is erased without being written down is gone, which is why the recording pass runs first, and why the returned vector paths are merged with real editable `<text>` in the Master SVG before anything reaches the artboard.

On the newest `main` the flow then asks whether to use `cell_no_ai`, a separate hidden-watermark handling step that ships alongside. Accepting it means waiting for the processed image to come back before vector recognition continues; skipping it means going ahead with the text-free image that was already checked. Installing that companion Skill is not the same as authorising paid processing, and the outcome of the third-party step depends on what the service returns and on whatever you check afterwards.

## One SVG parse, one Illustrator connection, batches of 20 to 50 paths

The SVG coming back from recognition is parsed exactly once and turned into a geometry cache that the rest of the run reuses, and a single Illustrator connection stays open for the whole job. Paths are then written in batches that follow the layer order of the original image, usually 20 to 50 at a time, with complex paths handled on their own instead of being forced into a batch.

Resumable geometry caches and stage results are listed among the deliverables, which implies a run can be picked back up. What that resumption actually covers is not documented: the README does not say whether a failed batch can be retried in place, whether the cache survives an Illustrator restart, or whether a half-written artboard can be unwound. Since the artboard is append-only by design, an interrupted run leaves partial geometry sitting there, and the only recovery described anywhere is deleting it by hand.

## Installing from the fixed v0.2.1 tag, then opening the document yourself

The environment contract is narrow: Windows 10/11 x64, PowerShell 5.1 or newer, Python 3.11 through 3.14, Adobe Illustrator 2026 (30.x), and Codex Desktop with built-in Image 2 available to the current task. The stable path pins the source at Git Tag `v0.2.1`:

```powershell
git clone --branch v0.2.1 --depth 1 https://github.com/yrui-cmd/cell-lct.git
Set-Location .\cell-lct
powershell -ExecutionPolicy Bypass -File .\setup.ps1
```

A first install pulls the locked dependencies, copies the Skill, prompts securely in the terminal for the API key, and runs diagnostics. The key must not end up in a command, the repository, a screenshot or a chat log; it is stored encrypted through DPAPI under the current Windows account and never ships with the project. If a Skill of the same name already exists and you have confirmed you want it replaced, the same script takes a force switch:

```powershell
powershell -ExecutionPolicy Bypass -File .\setup.ps1 -Force
```

Restart Codex, open a new task, and only then open Illustrator 2026 and the document you want drawn into. The request itself is one line of Chinese, sent as a message rather than typed into a terminal:

```text
使用 $cell-lct，根据我上传的内容或图片在当前 Illustrator 画板中作图，保留全部已有内容。
```

That asks cell-lct to draw into the current artboard from what you uploaded while keeping all existing content, which is the append-only promise stated as a prompt.

## The ZIP route verifies its own hash before extracting anything

Two files go into the ZIP path, the archive and its checksum, and the check happens before extraction rather than after installation:

```powershell
$zip = '.\cell-lct-v0.2.1.zip'
$expected = ((Get-Content "$zip.sha256") -split '\s+')[0]
$actual = (Get-FileHash $zip -Algorithm SHA256).Hash.ToLowerInvariant()
if ($actual -ne $expected) { throw 'SHA256 校验失败，停止安装。' }
Expand-Archive $zip -DestinationPath .\cell-lct-v0.2.1
Set-Location .\cell-lct-v0.2.1\cell-lct-v0.2.1
powershell -ExecutionPolicy Bypass -File .\setup.ps1
```

The throw stops the install on a hash mismatch. There is no Marketplace entry to install from, so a git tag or this archive are the only doors.

Diagnostics read Illustrator's registration and process state and deliberately do nothing else: they will not start, restart, focus, maximise or close the application.

```powershell
.\doctor.ps1
.\doctor.ps1 -VerifyApi -RequireIllustratorOpen
.\doctor.ps1 -Json
```

One cost rule is enforced here rather than in prose. When a single image is expected to consume more than 1 credit, the tool asks for confirmation before calling the upload API, and a refusal means nothing is uploaded at all. Once you confirm, neither processing nor downloading asks again.

## main and v0.2.1 are two different products

The two install tracks are not the same software at different ages. `main` carries the optional `cell_no_ai` handoff and suits anyone running the current full flow. The `v0.2.1` tag is described as a locked, release-verified Windows build without the later integrations, and the tag, the checksum file and the environment contract all refer to that stable line.

Reproducibility is taken seriously inside the repository: pinned Python dependencies in `requirements.lock`, a pinned runtime contract in `runtime-lock.json`, one-command install and diagnosis, Windows end-to-end tests, a separate manual Illustrator 2026 real-machine test, and a SHA256 file beside every release ZIP. CI runs the offline drawing chain on a Windows runner, while the Illustrator chain is triggered by hand on a self-hosted Windows runner carrying Illustrator 2026.

The boundary is stated plainly: the repository can pin its Skill, scripts, dependencies, tests and release files, but it cannot package Codex's built-in Image 2 or Adobe Illustrator itself. A second machine needs the same environment contract from `runtime-lock.json` and its own DPAPI key to behave the same way.

One gap is worth naming. The only release shown is v0.2.0 on 2026-08-25, while every install instruction names `v0.2.1`, and nothing in the documentation explains the difference. The last push was on 2026-09-26.

## Credits, and what the documentation never says they cost

This is the part with the least written down. The free allowance is handed out daily in a Douyin group, and private allowance is arranged through a Xiaohongshu account, so the credit supply runs through social channels rather than a published plan. No price per credit appears anywhere, and no per-image cost is stated. The only figure given is the threshold itself: more than 1 credit for one image triggers a confirmation prompt.

That leaves a reader unable to price a batch of forty figures, and unable to tell whether a failed run refunds anything. The optional `cell_no_ai` step is a second source of uncertainty on the same account.

Other silences matter for a long job. The README does not document rollback for a botched run, does not say whether a recognised path that lands badly can be removed without touching the rest of the artboard, and does not say what happens when Image 2 is unavailable in the current Codex task even though the environment list requires it. It also does not name the upstream API that the key belongs to.

## Against tracing the raster inside Illustrator yourself

The obvious alternative is not a competing tool but a different order of operations: select the raster in Illustrator and trace it, or redraw the shapes by hand. Tracing works in a single pass on what is already on screen, produces live paths immediately, and needs no API key, no Codex task and no model round trip. What it cannot do is anything with the lettering, because a trace of a caption gives you outlines shaped like letters and nothing about the string that was written. There is also no stage that restores the original layer order, and no geometry cache to reuse.

Cell-lct buys the missing text and ordering with a pipeline: record the type, have a model erase it, parse the returned SVG once, append in batches. For a full-page figure with axes, a legend and a heatmap, that is a real gain. For a two-line diagram, hand drawing finishes before the dependency install does.

## Conclusion

Adopt Cell-lct if your figures are stuck as rasters and you already run Windows 10/11 with Illustrator 2026 and Codex Desktop, and you are willing to give up cross-platform use in exchange for editable text. Skip it for a two-bar diagram you can draw by hand, and skip it on any machine that is not x64 Windows, because setup.ps1 has no other path. Before the first run, check the credit cost of one image against your own budget, because the documentation names a one-credit confirmation threshold but never states what a credit costs or what the upstream API is.

## FAQ

### Does Cell-lct run on macOS or Linux?

No supported path exists outside Windows. The environment requires Windows 10/11 x64, PowerShell 5.1 or newer, Python 3.11 through 3.14, Adobe Illustrator 2026 (30.x) and Codex Desktop, and installation is a PowerShell script.

### How does Cell-lct keep the text in my figure editable?

The first pass records the text content, position, size, font, weight, colour, rotation, alignment and layer, then Image 2 clears the lettering. Real editable `<text>` is merged into the Master SVG before the paths are written to the artboard.

### What is the cell_no_ai step in Cell-lct?

On the latest `main` branch the flow optionally hands the text-free image to a separate hidden-watermark handling Skill and waits for the processed result before continuing to vector recognition. Installing that Skill does not authorise paid processing, and the third-party result is only as good as what the service returns.

### Where does Cell-lct keep my API key?

It is encrypted through DPAPI under the current Windows account and is never distributed with the project. The documentation states the key should not be written into commands, the repository, screenshots or chat records.

### Can I install Cell-lct from a plugin marketplace?

There is no Marketplace entry. Installation happens from the fixed Git Tag `v0.2.1` or from a release ZIP paired with its own `.sha256` file, which is verified before extraction.

### Will Cell-lct overwrite what is already on my artboard?

No. The tool appends and never deletes, hides or replaces existing artboard content, and the PNG preview is exported only when the run finishes. You are expected to open the target document yourself before sending the task.

## Sources

- [Issues](https://github.com/yrui-cmd/cell-lct/issues)
- [License: MIT](https://github.com/yrui-cmd/cell-lct/blob/main/LICENSE)
- [README](https://github.com/yrui-cmd/cell-lct/blob/main/README.md)
- [Releases](https://github.com/yrui-cmd/cell-lct/releases)
- [yrui-cmd/cell-lct on GitHub](https://github.com/yrui-cmd/cell-lct)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/yrui-cmd-cell-lct