summaryrefslogtreecommitdiff
path: root/makima/src
diff options
context:
space:
mode:
Diffstat (limited to 'makima/src')
-rw-r--r--makima/src/daemon/storage/mod.rs5
-rw-r--r--makima/src/daemon/storage/patch.rs303
-rw-r--r--makima/src/daemon/task/manager.rs106
-rw-r--r--makima/src/daemon/ws/protocol.rs38
-rw-r--r--makima/src/db/models.rs18
-rw-r--r--makima/src/db/repository.rs19
-rw-r--r--makima/src/server/handlers/contract_chat.rs12
-rw-r--r--makima/src/server/handlers/contracts.rs4
-rw-r--r--makima/src/server/handlers/mesh.rs46
-rw-r--r--makima/src/server/handlers/mesh_chat.rs11
-rw-r--r--makima/src/server/handlers/mesh_daemon.rs92
-rw-r--r--makima/src/server/handlers/mesh_supervisor.rs13
-rw-r--r--makima/src/server/handlers/transcript_analysis.rs1
-rw-r--r--makima/src/server/state.rs3
14 files changed, 657 insertions, 14 deletions
diff --git a/makima/src/daemon/storage/mod.rs b/makima/src/daemon/storage/mod.rs
index cc5441a..e5457f7 100644
--- a/makima/src/daemon/storage/mod.rs
+++ b/makima/src/daemon/storage/mod.rs
@@ -5,4 +5,7 @@
mod patch;
-pub use patch::{create_patch, apply_patch, PatchError};
+pub use patch::{
+ apply_patch, create_export_patch, create_patch, get_head_sha, get_parent_sha, ExportPatchResult,
+ PatchError,
+};
diff --git a/makima/src/daemon/storage/patch.rs b/makima/src/daemon/storage/patch.rs
index 45624b5..0da4eda 100644
--- a/makima/src/daemon/storage/patch.rs
+++ b/makima/src/daemon/storage/patch.rs
@@ -141,6 +141,223 @@ pub async fn get_parent_sha(worktree_path: &Path) -> Result<String, PatchError>
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}
+/// Get the current HEAD commit SHA from a worktree.
+pub async fn get_head_sha(worktree_path: &Path) -> Result<String, PatchError> {
+ let output = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["rev-parse", "HEAD"])
+ .output()
+ .await
+ .map_err(|e| PatchError::GitCommand(format!("Failed to get HEAD SHA: {}", e)))?;
+
+ if !output.status.success() {
+ let stderr = String::from_utf8_lossy(&output.stderr);
+ return Err(PatchError::GitCommand(format!(
+ "git rev-parse HEAD failed: {}",
+ stderr
+ )));
+ }
+
+ Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
+/// Result of creating an export patch.
+#[derive(Debug, Clone)]
+pub struct ExportPatchResult {
+ /// The uncompressed, human-readable patch content.
+ pub patch_content: String,
+ /// Number of files changed in the patch.
+ pub files_count: usize,
+ /// Number of lines added.
+ pub lines_added: usize,
+ /// Number of lines removed.
+ pub lines_removed: usize,
+ /// The base commit SHA that the patch is diffed against.
+ pub base_commit_sha: String,
+}
+
+/// Create an uncompressed git diff patch for export.
+///
+/// This creates a human-readable patch that can be applied manually or
+/// shared as a file. Unlike `create_patch`, this version is not compressed
+/// and is suitable for display or export.
+///
+/// If `base_sha` is provided, the diff is between that commit and HEAD.
+/// If `base_sha` is None, it attempts to find the merge-base with the default branch
+/// or falls back to diffing uncommitted changes against HEAD.
+pub async fn create_export_patch(
+ worktree_path: &Path,
+ base_sha: Option<&str>,
+) -> Result<ExportPatchResult, PatchError> {
+ // Determine the base SHA to diff against
+ let resolved_base_sha = match base_sha {
+ Some(sha) => sha.to_string(),
+ None => {
+ // Try to find the merge-base with the default branch
+ // First, try to get the upstream tracking branch
+ let upstream_result = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])
+ .output()
+ .await;
+
+ let base = if let Ok(output) = upstream_result {
+ if output.status.success() {
+ let upstream = String::from_utf8_lossy(&output.stdout).trim().to_string();
+ // Get merge-base with upstream
+ let merge_base = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["merge-base", "HEAD", &upstream])
+ .output()
+ .await;
+
+ if let Ok(mb_output) = merge_base {
+ if mb_output.status.success() {
+ Some(String::from_utf8_lossy(&mb_output.stdout).trim().to_string())
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+ } else {
+ None
+ };
+
+ // If we couldn't find upstream, try common default branches
+ let base = if base.is_none() {
+ let default_branches = ["origin/main", "origin/master", "main", "master"];
+ let mut found_base = None;
+
+ for branch in default_branches {
+ let merge_base = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["merge-base", "HEAD", branch])
+ .output()
+ .await;
+
+ if let Ok(output) = merge_base {
+ if output.status.success() {
+ found_base = Some(String::from_utf8_lossy(&output.stdout).trim().to_string());
+ break;
+ }
+ }
+ }
+ found_base
+ } else {
+ base
+ };
+
+ // If still nothing, get the first commit or use HEAD~1
+ base.unwrap_or_else(|| {
+ // This will be used, but if HEAD~1 doesn't exist (only one commit),
+ // git diff will handle it gracefully
+ "HEAD~1".to_string()
+ })
+ }
+ };
+
+ // Get diff stats using --stat
+ let stat_output = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["diff", "--stat", &resolved_base_sha, "HEAD"])
+ .output()
+ .await
+ .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff --stat: {}", e)))?;
+
+ // Parse the stat output to get line counts
+ let (lines_added, lines_removed) = if stat_output.status.success() {
+ parse_diff_stat(&String::from_utf8_lossy(&stat_output.stdout))
+ } else {
+ (0, 0)
+ };
+
+ // Get the actual diff content
+ let diff_output = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["diff", &resolved_base_sha, "HEAD"])
+ .output()
+ .await
+ .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff: {}", e)))?;
+
+ if !diff_output.status.success() {
+ let stderr = String::from_utf8_lossy(&diff_output.stderr);
+ return Err(PatchError::GitCommand(format!("git diff failed: {}", stderr)));
+ }
+
+ let patch_content = String::from_utf8_lossy(&diff_output.stdout).to_string();
+
+ // Check for empty patch
+ if patch_content.trim().is_empty() {
+ return Err(PatchError::EmptyPatch);
+ }
+
+ // Count files changed
+ let files_output = Command::new("git")
+ .current_dir(worktree_path)
+ .args(["diff", "--name-only", &resolved_base_sha, "HEAD"])
+ .output()
+ .await
+ .map_err(|e| PatchError::GitCommand(format!("Failed to count files: {}", e)))?;
+
+ let files_count = if files_output.status.success() {
+ String::from_utf8_lossy(&files_output.stdout)
+ .lines()
+ .filter(|l| !l.is_empty())
+ .count()
+ } else {
+ 0
+ };
+
+ Ok(ExportPatchResult {
+ patch_content,
+ files_count,
+ lines_added,
+ lines_removed,
+ base_commit_sha: resolved_base_sha,
+ })
+}
+
+/// Parse git diff --stat output to extract lines added and removed.
+/// The last line typically looks like: " 3 files changed, 45 insertions(+), 12 deletions(-)"
+fn parse_diff_stat(stat_output: &str) -> (usize, usize) {
+ let mut lines_added = 0;
+ let mut lines_removed = 0;
+
+ // Look for the summary line at the end
+ for line in stat_output.lines().rev() {
+ let line = line.trim();
+ if line.contains("changed") || line.contains("insertion") || line.contains("deletion") {
+ // Parse insertions
+ if let Some(idx) = line.find("insertion") {
+ let before = &line[..idx];
+ if let Some(num_str) = before.split_whitespace().last() {
+ if let Ok(num) = num_str.parse::<usize>() {
+ lines_added = num;
+ }
+ }
+ }
+ // Parse deletions
+ if let Some(idx) = line.find("deletion") {
+ let before = &line[..idx];
+ if let Some(num_str) = before.split(',').last() {
+ if let Some(num_str) = num_str.trim().split_whitespace().next() {
+ if let Ok(num) = num_str.parse::<usize>() {
+ lines_removed = num;
+ }
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ (lines_added, lines_removed)
+}
+
/// Checkout a specific commit in the worktree.
pub async fn checkout_commit(worktree_path: &Path, sha: &str) -> Result<(), PatchError> {
let output = Command::new("git")
@@ -290,4 +507,90 @@ mod tests {
let result = create_patch(path, &head_sha).await;
assert!(matches!(result, Err(PatchError::EmptyPatch)));
}
+
+ #[tokio::test]
+ async fn test_create_export_patch() {
+ let dir = setup_test_repo().await;
+ let path = dir.path();
+
+ // Get the initial commit SHA before making changes
+ let initial_sha = get_head_sha(path).await.unwrap();
+
+ // Make some changes and commit
+ fs::write(path.join("file.txt"), "modified content").unwrap();
+ fs::write(path.join("new_file.txt"), "new file content").unwrap();
+ Command::new("git")
+ .current_dir(path)
+ .args(["add", "."])
+ .output()
+ .await
+ .unwrap();
+ Command::new("git")
+ .current_dir(path)
+ .args(["commit", "-m", "changes for export"])
+ .output()
+ .await
+ .unwrap();
+
+ // Create export patch with explicit base
+ let result = create_export_patch(path, Some(&initial_sha)).await.unwrap();
+
+ // Verify the result
+ assert!(!result.patch_content.is_empty());
+ assert_eq!(result.files_count, 2); // file.txt and new_file.txt
+ assert!(result.lines_added > 0);
+ assert_eq!(result.base_commit_sha, initial_sha);
+
+ // The patch should contain diff headers
+ assert!(result.patch_content.contains("diff --git"));
+ assert!(result.patch_content.contains("new_file.txt"));
+ }
+
+ #[tokio::test]
+ async fn test_create_export_patch_no_base() {
+ let dir = setup_test_repo().await;
+ let path = dir.path();
+
+ // Make a second commit so we have something to diff
+ fs::write(path.join("file.txt"), "modified").unwrap();
+ Command::new("git")
+ .current_dir(path)
+ .args(["add", "."])
+ .output()
+ .await
+ .unwrap();
+ Command::new("git")
+ .current_dir(path)
+ .args(["commit", "-m", "second commit"])
+ .output()
+ .await
+ .unwrap();
+
+ // Create export patch without explicit base (will use HEAD~1)
+ let result = create_export_patch(path, None).await.unwrap();
+
+ // Verify the result
+ assert!(!result.patch_content.is_empty());
+ assert_eq!(result.files_count, 1);
+ assert!(result.patch_content.contains("diff --git"));
+ }
+
+ #[tokio::test]
+ async fn test_parse_diff_stat() {
+ // Test the parse_diff_stat function with various formats
+ let stat1 = " 3 files changed, 45 insertions(+), 12 deletions(-)";
+ let (added, removed) = parse_diff_stat(stat1);
+ assert_eq!(added, 45);
+ assert_eq!(removed, 12);
+
+ let stat2 = " 1 file changed, 10 insertions(+)";
+ let (added, removed) = parse_diff_stat(stat2);
+ assert_eq!(added, 10);
+ assert_eq!(removed, 0);
+
+ let stat3 = " 2 files changed, 5 deletions(-)";
+ let (added, removed) = parse_diff_stat(stat3);
+ assert_eq!(added, 0);
+ assert_eq!(removed, 5);
+ }
}
diff --git a/makima/src/daemon/task/manager.rs b/makima/src/daemon/task/manager.rs
index 8abff3f..bbcf661 100644
--- a/makima/src/daemon/task/manager.rs
+++ b/makima/src/daemon/task/manager.rs
@@ -995,6 +995,8 @@ pub struct ManagedTask {
pub concurrency_key: Uuid,
/// Whether to run in autonomous loop mode.
pub autonomous_loop: bool,
+ /// Whether the contract is in local-only mode (skips automatic completion actions).
+ pub local_only: bool,
/// Time task was created.
pub created_at: Instant,
/// Time task started running.
@@ -1692,6 +1694,7 @@ impl TaskManager {
conversation_history,
patch_data,
patch_base_sha,
+ local_only,
} => {
tracing::info!(
task_id = %task_id,
@@ -1718,7 +1721,7 @@ impl TaskManager {
parent_task_id, depth, is_orchestrator, is_supervisor,
target_repo_path, completion_action, continue_from_task_id,
copy_files, contract_id, autonomous_loop, resume_session,
- conversation_history, patch_data, patch_base_sha,
+ conversation_history, patch_data, patch_base_sha, local_only,
).await?;
}
DaemonCommand::PauseTask { task_id } => {
@@ -1796,6 +1799,7 @@ impl TaskManager {
let target_repo_path = task.target_repo_path.clone();
let completion_action = task.completion_action.clone();
let contract_id = task.contract_id;
+ let local_only = task.local_only;
// Spawn in background to not block the command handler
tokio::spawn(async move {
@@ -1818,6 +1822,7 @@ impl TaskManager {
None, // conversation_history - not needed for fresh respawn
None, // patch_data - not available for respawn
None, // patch_base_sha - not available for respawn
+ local_only,
).await {
tracing::error!(
task_id = %task_id,
@@ -2009,6 +2014,10 @@ impl TaskManager {
tracing::info!(source_dir = ?source_dir, "Inheriting git config");
self.handle_inherit_git_config(source_dir).await?;
}
+ DaemonCommand::CreateExportPatch { task_id, base_sha } => {
+ tracing::info!(task_id = %task_id, base_sha = ?base_sha, "Creating export patch");
+ self.handle_create_export_patch(task_id, base_sha).await?;
+ }
DaemonCommand::RestartDaemon => {
tracing::info!("Received restart command from server, initiating daemon restart...");
// Shutdown all running tasks gracefully
@@ -2046,6 +2055,7 @@ impl TaskManager {
conversation_history: Option<serde_json::Value>,
patch_data: Option<String>,
patch_base_sha: Option<String>,
+ local_only: bool,
) -> TaskResult<()> {
tracing::info!(task_id = %task_id, is_orchestrator = is_orchestrator, is_supervisor = is_supervisor, depth = depth, patch_available = patch_data.is_some(), "=== SPAWN_TASK START ===");
@@ -2096,6 +2106,7 @@ impl TaskManager {
contract_id,
concurrency_key,
autonomous_loop,
+ local_only,
created_at: Instant::now(),
started_at: None,
completed_at: None,
@@ -2122,7 +2133,7 @@ impl TaskManager {
task_id, task_name, plan, repo_url, base_branch, target_branch,
is_orchestrator, is_supervisor, target_repo_path, completion_action,
continue_from_task_id, copy_files, contract_id, autonomous_loop, resume_session,
- conversation_history, patch_data, patch_base_sha,
+ conversation_history, patch_data, patch_base_sha, local_only,
).await {
tracing::error!(task_id = %task_id, error = %e, "Task execution failed");
inner.mark_failed(task_id, &e.to_string()).await;
@@ -2729,6 +2740,86 @@ impl TaskManager {
Ok(())
}
+ /// Handle CreateExportPatch command.
+ ///
+ /// Creates an uncompressed, human-readable git patch for export.
+ async fn handle_create_export_patch(
+ &self,
+ task_id: Uuid,
+ base_sha: Option<String>,
+ ) -> Result<(), DaemonError> {
+ // Get task's worktree path
+ let worktree_result = self.get_task_worktree_path(task_id).await;
+
+ let msg = match worktree_result {
+ Ok(worktree_path) => {
+ // Create the export patch
+ match storage::create_export_patch(&worktree_path, base_sha.as_deref()).await {
+ Ok(result) => {
+ tracing::info!(
+ task_id = %task_id,
+ files_count = result.files_count,
+ lines_added = result.lines_added,
+ lines_removed = result.lines_removed,
+ base_commit_sha = %result.base_commit_sha,
+ "Export patch created successfully"
+ );
+
+ DaemonMessage::ExportPatchCreated {
+ task_id,
+ success: true,
+ patch_content: Some(result.patch_content),
+ files_count: Some(result.files_count),
+ lines_added: Some(result.lines_added),
+ lines_removed: Some(result.lines_removed),
+ base_commit_sha: Some(result.base_commit_sha),
+ error: None,
+ }
+ }
+ Err(e) => {
+ tracing::warn!(
+ task_id = %task_id,
+ error = %e,
+ "Failed to create export patch"
+ );
+
+ DaemonMessage::ExportPatchCreated {
+ task_id,
+ success: false,
+ patch_content: None,
+ files_count: None,
+ lines_added: None,
+ lines_removed: None,
+ base_commit_sha: None,
+ error: Some(e.to_string()),
+ }
+ }
+ }
+ }
+ Err(e) => {
+ tracing::warn!(
+ task_id = %task_id,
+ error = %e,
+ "Failed to get worktree path for export patch"
+ );
+
+ DaemonMessage::ExportPatchCreated {
+ task_id,
+ success: false,
+ patch_content: None,
+ files_count: None,
+ lines_added: None,
+ lines_removed: None,
+ base_commit_sha: None,
+ error: Some(format!("Task not found or has no worktree: {}", e)),
+ }
+ }
+ };
+
+ let _ = self.ws_tx.send(msg).await;
+ Ok(())
+ }
+
/// Handle ReadRepoFile command.
///
/// Reads a file from a repository on the daemon's filesystem and sends
@@ -3570,6 +3661,7 @@ impl TaskManagerInner {
conversation_history: Option<serde_json::Value>,
patch_data: Option<String>,
patch_base_sha: Option<String>,
+ local_only: bool,
) -> Result<(), DaemonError> {
tracing::info!(task_id = %task_id, is_orchestrator = is_orchestrator, is_supervisor = is_supervisor, resume_session = resume_session, has_patch = patch_data.is_some(), "=== RUN_TASK START ===");
@@ -4704,9 +4796,15 @@ impl TaskManagerInner {
}
}
- // Execute completion action if task succeeded
+ // Execute completion action if task succeeded (skip in local_only mode)
let completion_result = if success {
- if let Some(ref action) = completion_action {
+ if local_only {
+ tracing::info!(
+ task_id = %task_id,
+ "Skipping completion action - contract is in local_only mode"
+ );
+ Ok(None)
+ } else if let Some(ref action) = completion_action {
if action != "none" {
self.execute_completion_action(
task_id,
diff --git a/makima/src/daemon/ws/protocol.rs b/makima/src/daemon/ws/protocol.rs
index 2e7caef..018dc7b 100644
--- a/makima/src/daemon/ws/protocol.rs
+++ b/makima/src/daemon/ws/protocol.rs
@@ -316,6 +316,30 @@ pub enum DaemonMessage {
message: String,
},
+ /// Response to CreateExportPatch command.
+ ExportPatchCreated {
+ #[serde(rename = "taskId")]
+ task_id: Uuid,
+ success: bool,
+ /// The uncompressed, human-readable patch content.
+ #[serde(rename = "patchContent")]
+ patch_content: Option<String>,
+ /// Number of files changed.
+ #[serde(rename = "filesCount")]
+ files_count: Option<usize>,
+ /// Lines added.
+ #[serde(rename = "linesAdded")]
+ lines_added: Option<usize>,
+ /// Lines removed.
+ #[serde(rename = "linesRemoved")]
+ lines_removed: Option<usize>,
+ /// The base commit SHA that the patch is diffed against.
+ #[serde(rename = "baseCommitSha")]
+ base_commit_sha: Option<String>,
+ /// Error message if failed.
+ error: Option<String>,
+ },
+
/// Response to InheritGitConfig command.
GitConfigInherited {
success: bool,
@@ -422,6 +446,9 @@ pub enum DaemonCommand {
/// Commit SHA to apply the patch on top of.
#[serde(rename = "patchBaseSha", default, skip_serializing_if = "Option::is_none")]
patch_base_sha: Option<String>,
+ /// Whether the contract is in local-only mode (skips automatic completion actions).
+ #[serde(rename = "localOnly", default)]
+ local_only: bool,
},
/// Pause a running task.
@@ -646,6 +673,17 @@ pub enum DaemonCommand {
delete_branch: bool,
},
+ /// Create an uncompressed git patch for export.
+ /// Returns a human-readable patch that can be applied manually or shared.
+ CreateExportPatch {
+ #[serde(rename = "taskId")]
+ task_id: Uuid,
+ /// Optional base SHA to diff against. If not provided, will try to find
+ /// the merge-base with the default branch.
+ #[serde(rename = "baseSha")]
+ base_sha: Option<String>,
+ },
+
/// Inherit git config (user.email, user.name) from a directory.
/// This config will be applied to all future worktrees.
InheritGitConfig {
diff --git a/makima/src/db/models.rs b/makima/src/db/models.rs
index 95517a1..9c2d072 100644
--- a/makima/src/db/models.rs
+++ b/makima/src/db/models.rs
@@ -1326,6 +1326,11 @@ pub struct Contract {
#[sqlx(json)]
#[serde(default)]
pub completed_deliverables: serde_json::Value,
+ /// Whether this contract operates in local-only mode.
+ /// When enabled, automatic completion actions (branch, merge, pr) are skipped,
+ /// allowing users to manually handle code changes via patch files or other means.
+ #[serde(default)]
+ pub local_only: bool,
pub version: i32,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
@@ -1441,6 +1446,9 @@ pub struct ContractSummary {
pub status: String,
/// Supervisor task ID for contract orchestration
pub supervisor_task_id: Option<Uuid>,
+ /// When true, tasks do not auto-execute completion actions and work stays in worktrees.
+ #[serde(default)]
+ pub local_only: bool,
pub file_count: i64,
pub task_count: i64,
pub repository_count: i64,
@@ -1495,6 +1503,11 @@ pub struct CreateContractRequest {
/// phase outputs before progressing to the next phase.
#[serde(default)]
pub phase_guard: Option<bool>,
+ /// Enable local-only mode for this contract.
+ /// When enabled, automatic completion actions (branch, merge, pr) are skipped,
+ /// allowing users to manually handle code changes via patch files or other means.
+ #[serde(default)]
+ pub local_only: Option<bool>,
}
/// Request payload for updating a contract
@@ -1516,6 +1529,11 @@ pub struct UpdateContractRequest {
/// phase outputs before progressing to the next phase.
#[serde(default)]
pub phase_guard: Option<bool>,
+ /// Enable or disable local-only mode for this contract.
+ /// When enabled, automatic completion actions (branch, merge, pr) are skipped,
+ /// allowing users to manually handle code changes via patch files or other means.
+ #[serde(default)]
+ pub local_only: Option<bool>,
/// Version for optimistic locking
pub version: Option<i32>,
}
diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs
index b55b05e..6d6642b 100644
--- a/makima/src/db/repository.rs
+++ b/makima/src/db/repository.rs
@@ -2175,11 +2175,12 @@ pub async fn create_contract_for_owner(
let autonomous_loop = req.autonomous_loop.unwrap_or(false);
let phase_guard = req.phase_guard.unwrap_or(false);
+ let local_only = req.local_only.unwrap_or(false);
sqlx::query_as::<_, Contract>(
r#"
- INSERT INTO contracts (owner_id, name, description, contract_type, phase, autonomous_loop, phase_guard)
- VALUES ($1, $2, $3, $4, $5, $6, $7)
+ INSERT INTO contracts (owner_id, name, description, contract_type, phase, autonomous_loop, phase_guard, local_only)
+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
RETURNING *
"#,
)
@@ -2190,6 +2191,7 @@ pub async fn create_contract_for_owner(
.bind(phase)
.bind(autonomous_loop)
.bind(phase_guard)
+ .bind(local_only)
.fetch_one(pool)
.await
}
@@ -2222,7 +2224,7 @@ pub async fn list_contracts_for_owner(
r#"
SELECT
c.id, c.name, c.description, c.contract_type, c.phase, c.status,
- c.supervisor_task_id, c.version, c.created_at,
+ c.supervisor_task_id, c.local_only, c.version, c.created_at,
(SELECT COUNT(*) FROM files WHERE contract_id = c.id) as file_count,
(SELECT COUNT(*) FROM tasks WHERE contract_id = c.id) as task_count,
(SELECT COUNT(*) FROM contract_repositories WHERE contract_id = c.id) as repository_count
@@ -2246,7 +2248,7 @@ pub async fn get_contract_summary_for_owner(
r#"
SELECT
c.id, c.name, c.description, c.contract_type, c.phase, c.status,
- c.supervisor_task_id, c.version, c.created_at,
+ c.supervisor_task_id, c.local_only, c.version, c.created_at,
(SELECT COUNT(*) FROM files WHERE contract_id = c.id) as file_count,
(SELECT COUNT(*) FROM tasks WHERE contract_id = c.id) as task_count,
(SELECT COUNT(*) FROM contract_repositories WHERE contract_id = c.id) as repository_count
@@ -2290,14 +2292,15 @@ pub async fn update_contract_for_owner(
let supervisor_task_id = req.supervisor_task_id.or(existing.supervisor_task_id);
let autonomous_loop = req.autonomous_loop.unwrap_or(existing.autonomous_loop);
let phase_guard = req.phase_guard.unwrap_or(existing.phase_guard);
+ let local_only = req.local_only.unwrap_or(existing.local_only);
let result = if req.version.is_some() {
sqlx::query_as::<_, Contract>(
r#"
UPDATE contracts
SET name = $3, description = $4, phase = $5, status = $6,
- supervisor_task_id = $7, autonomous_loop = $8, phase_guard = $9, version = version + 1, updated_at = NOW()
- WHERE id = $1 AND owner_id = $2 AND version = $10
+ supervisor_task_id = $7, autonomous_loop = $8, phase_guard = $9, local_only = $10, version = version + 1, updated_at = NOW()
+ WHERE id = $1 AND owner_id = $2 AND version = $11
RETURNING *
"#,
)
@@ -2310,6 +2313,7 @@ pub async fn update_contract_for_owner(
.bind(supervisor_task_id)
.bind(autonomous_loop)
.bind(phase_guard)
+ .bind(local_only)
.bind(req.version.unwrap())
.fetch_optional(pool)
.await?
@@ -2318,7 +2322,7 @@ pub async fn update_contract_for_owner(
r#"
UPDATE contracts
SET name = $3, description = $4, phase = $5, status = $6,
- supervisor_task_id = $7, autonomous_loop = $8, phase_guard = $9, version = version + 1, updated_at = NOW()
+ supervisor_task_id = $7, autonomous_loop = $8, phase_guard = $9, local_only = $10, version = version + 1, updated_at = NOW()
WHERE id = $1 AND owner_id = $2
RETURNING *
"#,
@@ -2332,6 +2336,7 @@ pub async fn update_contract_for_owner(
.bind(supervisor_task_id)
.bind(autonomous_loop)
.bind(phase_guard)
+ .bind(local_only)
.fetch_optional(pool)
.await?
};
diff --git a/makima/src/server/handlers/contract_chat.rs b/makima/src/server/handlers/contract_chat.rs
index e035368..e6ee8d4 100644
--- a/makima/src/server/handlers/contract_chat.rs
+++ b/makima/src/server/handlers/contract_chat.rs
@@ -1567,6 +1567,16 @@ async fn handle_contract_request(
}
};
+ // Get local_only from contract if task has one
+ let local_only = if let Some(contract_id) = task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Send SpawnTask command to daemon
let command = DaemonCommand::SpawnTask {
task_id,
@@ -1589,6 +1599,7 @@ async fn handle_contract_request(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
if let Err(e) = command_sender.send(command).await {
@@ -2574,6 +2585,7 @@ async fn handle_contract_request(
initial_phase: Some("research".to_string()),
autonomous_loop: None,
phase_guard: None,
+ local_only: None,
};
let contract = match repository::create_contract_for_owner(pool, owner_id, contract_req).await {
diff --git a/makima/src/server/handlers/contracts.rs b/makima/src/server/handlers/contracts.rs
index de3164c..3498063 100644
--- a/makima/src/server/handlers/contracts.rs
+++ b/makima/src/server/handlers/contracts.rs
@@ -366,6 +366,7 @@ pub async fn create_contract(
phase: contract.phase,
status: contract.status,
supervisor_task_id: contract.supervisor_task_id,
+ local_only: contract.local_only,
file_count: 0,
task_count: 0,
repository_count: 0,
@@ -387,6 +388,7 @@ pub async fn create_contract(
phase: contract.phase,
status: contract.status,
supervisor_task_id: contract.supervisor_task_id,
+ local_only: contract.local_only,
file_count: 0,
task_count: 0,
repository_count: 0,
@@ -515,6 +517,7 @@ pub async fn update_contract(
phase: contract.phase,
status: contract.status,
supervisor_task_id: contract.supervisor_task_id,
+ local_only: contract.local_only,
file_count: 0,
task_count: 0,
repository_count: 0,
@@ -1399,6 +1402,7 @@ pub async fn change_phase(
phase: updated_contract.phase,
status: updated_contract.status,
supervisor_task_id: updated_contract.supervisor_task_id,
+ local_only: updated_contract.local_only,
file_count: 0,
task_count: 0,
repository_count: 0,
diff --git a/makima/src/server/handlers/mesh.rs b/makima/src/server/handlers/mesh.rs
index 545d1ea..19958e7 100644
--- a/makima/src/server/handlers/mesh.rs
+++ b/makima/src/server/handlers/mesh.rs
@@ -599,6 +599,16 @@ pub async fn start_task(
.into_response();
}
+ // Get local_only flag from contract if task has one
+ let local_only = if let Some(contract_id) = task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, auth.owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Get list of daemons that have previously failed this task
let mut exclude_daemon_ids: Vec<Uuid> = task.failed_daemon_ids.clone().unwrap_or_default();
@@ -694,6 +704,7 @@ pub async fn start_task(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
tracing::info!(
@@ -746,6 +757,7 @@ pub async fn start_task(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
if state.send_daemon_command(alt_daemon_id, alt_command).await.is_ok() {
@@ -1128,6 +1140,16 @@ pub async fn send_message(
};
if let Ok(Some(updated_task)) = repository::update_task_for_owner(pool, id, auth.owner_id, update_req).await {
+ // Get local_only from contract if task has one
+ let local_only = if let Some(contract_id) = updated_task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, auth.owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Send spawn command to new daemon
let spawn_cmd = DaemonCommand::SpawnTask {
task_id: id,
@@ -1150,6 +1172,7 @@ pub async fn send_message(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
if state.send_daemon_command(new_daemon_id, spawn_cmd).await.is_ok() {
@@ -2293,6 +2316,16 @@ pub async fn reassign_task(
}
};
+ // Get local_only from contract if task has one
+ let local_only = if let Some(contract_id) = task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, auth.owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Send SpawnTask command to daemon for the new task
let command = DaemonCommand::SpawnTask {
task_id: new_task.id,
@@ -2315,6 +2348,7 @@ pub async fn reassign_task(
conversation_history: None,
patch_data,
patch_base_sha,
+ local_only,
};
tracing::info!(
@@ -2620,6 +2654,16 @@ pub async fn continue_task(
};
let is_orchestrator = task.depth == 0 && subtask_count > 0;
+ // Get local_only from contract if task has one
+ let local_only = if let Some(contract_id) = task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, auth.owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Send SpawnTask command to daemon
let command = DaemonCommand::SpawnTask {
task_id: id,
@@ -2642,6 +2686,7 @@ pub async fn continue_task(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
tracing::info!(
@@ -3562,6 +3607,7 @@ pub async fn branch_task(
conversation_history: updated_task.conversation_state.clone(),
patch_data,
patch_base_sha,
+ local_only: false, // No contract, so not local_only
};
if let Err(e) = state.send_daemon_command(target_daemon_id, command).await {
diff --git a/makima/src/server/handlers/mesh_chat.rs b/makima/src/server/handlers/mesh_chat.rs
index 1ff0724..eb35728 100644
--- a/makima/src/server/handlers/mesh_chat.rs
+++ b/makima/src/server/handlers/mesh_chat.rs
@@ -1131,6 +1131,16 @@ async fn handle_mesh_request(
}
};
+ // Get local_only from contract if task has one
+ let local_only = if let Some(contract_id) = task.contract_id {
+ match repository::get_contract_for_owner(pool, contract_id, owner_id).await {
+ Ok(Some(contract)) => contract.local_only,
+ _ => false,
+ }
+ } else {
+ false
+ };
+
// Send SpawnTask command to daemon
let command = DaemonCommand::SpawnTask {
task_id,
@@ -1153,6 +1163,7 @@ async fn handle_mesh_request(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only,
};
match state.send_daemon_command(target_daemon_id, command).await {
diff --git a/makima/src/server/handlers/mesh_daemon.rs b/makima/src/server/handlers/mesh_daemon.rs
index 0ba37d2..0aea40e 100644
--- a/makima/src/server/handlers/mesh_daemon.rs
+++ b/makima/src/server/handlers/mesh_daemon.rs
@@ -448,6 +448,29 @@ pub enum DaemonMessage {
/// Error message if operation failed
error: Option<String>,
},
+ /// Response to CreateExportPatch command
+ ExportPatchCreated {
+ #[serde(rename = "taskId")]
+ task_id: Uuid,
+ success: bool,
+ /// The uncompressed, human-readable patch content
+ #[serde(rename = "patchContent")]
+ patch_content: Option<String>,
+ /// Number of files changed
+ #[serde(rename = "filesCount")]
+ files_count: Option<usize>,
+ /// Lines added
+ #[serde(rename = "linesAdded")]
+ lines_added: Option<usize>,
+ /// Lines removed
+ #[serde(rename = "linesRemoved")]
+ lines_removed: Option<usize>,
+ /// The base commit SHA that the patch is diffed against
+ #[serde(rename = "baseCommitSha")]
+ base_commit_sha: Option<String>,
+ /// Error message if failed
+ error: Option<String>,
+ },
/// Response to MergeTaskToTarget command
MergeToTargetResult {
#[serde(rename = "taskId")]
@@ -1778,6 +1801,75 @@ async fn handle_daemon_connection(socket: WebSocket, state: SharedState, auth_re
);
}
}
+ Ok(DaemonMessage::ExportPatchCreated {
+ task_id,
+ success,
+ patch_content,
+ files_count,
+ lines_added,
+ lines_removed,
+ base_commit_sha,
+ error,
+ }) => {
+ if success {
+ tracing::info!(
+ task_id = %task_id,
+ files_count = ?files_count,
+ lines_added = ?lines_added,
+ lines_removed = ?lines_removed,
+ base_commit_sha = ?base_commit_sha,
+ patch_len = patch_content.as_ref().map(|p| p.len()),
+ "Export patch created successfully"
+ );
+
+ // Broadcast as task output so UI can access the result
+ let output_text = format!(
+ "✓ Export patch created: {} files changed, +{} -{} lines (base: {})",
+ files_count.unwrap_or(0),
+ lines_added.unwrap_or(0),
+ lines_removed.unwrap_or(0),
+ base_commit_sha.as_deref().unwrap_or("unknown")
+ );
+ state.broadcast_task_output(TaskOutputNotification {
+ task_id,
+ owner_id: Some(owner_id),
+ message_type: "export_patch".to_string(),
+ content: output_text,
+ tool_name: None,
+ tool_input: Some(serde_json::json!({
+ "patchContent": patch_content,
+ "filesCount": files_count,
+ "linesAdded": lines_added,
+ "linesRemoved": lines_removed,
+ "baseCommitSha": base_commit_sha,
+ })),
+ is_error: None,
+ cost_usd: None,
+ duration_ms: None,
+ is_partial: false,
+ });
+ } else {
+ tracing::warn!(
+ task_id = %task_id,
+ error = ?error,
+ "Failed to create export patch"
+ );
+
+ // Broadcast error
+ state.broadcast_task_output(TaskOutputNotification {
+ task_id,
+ owner_id: Some(owner_id),
+ message_type: "error".to_string(),
+ content: format!("✗ Export patch failed: {}", error.unwrap_or_else(|| "Unknown error".to_string())),
+ tool_name: None,
+ tool_input: None,
+ is_error: Some(true),
+ cost_usd: None,
+ duration_ms: None,
+ is_partial: false,
+ });
+ }
+ }
Err(e) => {
tracing::warn!("Failed to parse daemon message: {}", e);
}
diff --git a/makima/src/server/handlers/mesh_supervisor.rs b/makima/src/server/handlers/mesh_supervisor.rs
index d1a1a99..a654a05 100644
--- a/makima/src/server/handlers/mesh_supervisor.rs
+++ b/makima/src/server/handlers/mesh_supervisor.rs
@@ -297,6 +297,12 @@ pub async fn try_start_pending_task(
return Ok(None);
}
+ // Get contract to check local_only flag
+ let contract = repository::get_contract_for_owner(pool, contract_id, owner_id)
+ .await
+ .map_err(|e| format!("Failed to get contract: {}", e))?
+ .ok_or_else(|| "Contract not found".to_string())?;
+
// Try each pending task until we find one we can start
for task in &pending_tasks {
// Get excluded daemon IDs for this task (daemons that have already failed it)
@@ -399,6 +405,7 @@ pub async fn try_start_pending_task(
conversation_history: None,
patch_data,
patch_base_sha,
+ local_only: contract.local_only,
};
if let Err(e) = state.send_daemon_command(daemon.id, cmd).await {
@@ -532,8 +539,8 @@ pub async fn spawn_task(
let pool = state.db_pool.as_ref().unwrap();
- // Verify contract exists
- let _contract = match repository::get_contract_for_owner(pool, request.contract_id, owner_id).await {
+ // Verify contract exists and get local_only flag
+ let contract = match repository::get_contract_for_owner(pool, request.contract_id, owner_id).await {
Ok(Some(c)) => c,
Ok(None) => {
return (
@@ -711,6 +718,7 @@ pub async fn spawn_task(
conversation_history: None,
patch_data: None,
patch_base_sha: None,
+ local_only: contract.local_only,
};
if let Err(e) = state.send_daemon_command(daemon.id, cmd).await {
@@ -2133,6 +2141,7 @@ pub async fn resume_supervisor(
conversation_history: Some(supervisor_state.conversation_history.clone()), // Fallback if worktree missing
patch_data,
patch_base_sha,
+ local_only: contract.local_only,
};
if let Err(e) = state.send_daemon_command(target_daemon_id, command).await {
diff --git a/makima/src/server/handlers/transcript_analysis.rs b/makima/src/server/handlers/transcript_analysis.rs
index 3b71eca..8eb50c7 100644
--- a/makima/src/server/handlers/transcript_analysis.rs
+++ b/makima/src/server/handlers/transcript_analysis.rs
@@ -278,6 +278,7 @@ pub async fn create_contract_from_analysis(
initial_phase: Some("research".to_string()),
autonomous_loop: None,
phase_guard: None,
+ local_only: None,
};
let contract = match repository::create_contract_for_owner(pool, auth.owner_id, contract_req).await {
diff --git a/makima/src/server/state.rs b/makima/src/server/state.rs
index 988f657..c579f0f 100644
--- a/makima/src/server/state.rs
+++ b/makima/src/server/state.rs
@@ -238,6 +238,9 @@ pub enum DaemonCommand {
/// Commit SHA to apply the patch on top of
#[serde(rename = "patchBaseSha", default, skip_serializing_if = "Option::is_none")]
patch_base_sha: Option<String>,
+ /// Whether the contract is in local-only mode (skips automatic completion actions)
+ #[serde(rename = "localOnly", default)]
+ local_only: bool,
},
/// Pause a running task
PauseTask {
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-21 02:41:20 +0000